Java-クイックガイド
Javaプログラミング言語は元々SunMicrosystemsによって開発され、James Goslingによって開始され、1995年にSun MicrosystemsのJavaプラットフォーム(Java 1.0 [J2SE])のコアコンポーネントとしてリリースされました。
Java StandardEditionの最新リリースはJavaSE 8です。Javaの進歩とその普及に伴い、さまざまなタイプのプラットフォームに適合するように複数の構成が構築されました。例:エンタープライズアプリケーション用のJ2EE、モバイルアプリケーション用のJ2ME。
新しいJ2バージョンは、それぞれJava SE、Java EE、およびJavaMEに名前が変更されました。JavaはWrite Once, Run Anywhere.
Javaは-
Object Oriented− Javaでは、すべてがオブジェクトです。Javaはオブジェクトモデルに基づいているため、簡単に拡張できます。
Platform Independent−CやC ++を含む他の多くのプログラミング言語とは異なり、Javaがコンパイルされると、プラットフォーム固有のマシンではなく、プラットフォームに依存しないバイトコードにコンパイルされます。このバイトコードはWebを介して配布され、実行されているプラットフォーム上の仮想マシン(JVM)によって解釈されます。
Simple− Javaは、習得しやすいように設計されています。OOP Javaの基本的な概念を理解していれば、習得するのは簡単です。
Secure− Javaの安全な機能により、ウイルスや改ざんのないシステムの開発が可能になります。認証技術は、公開鍵暗号化に基づいています。
Architecture-neutral − Javaコンパイラは、アーキテクチャに依存しないオブジェクトファイル形式を生成します。これにより、Javaランタイムシステムが存在する場合、コンパイルされたコードが多くのプロセッサで実行可能になります。
Portable−アーキテクチャに中立であり、仕様の実装に依存する側面がないため、Javaは移植可能です。Javaのコンパイラは、POSIXサブセットであるクリーンな移植性境界を使用してANSICで記述されています。
Robust − Javaは、主にコンパイル時のエラーチェックとランタイムチェックに重点を置くことにより、エラーが発生しやすい状況を排除するよう努めています。
Multithreaded− Javaのマルチスレッド機能を使用すると、多くのタスクを同時に実行できるプログラムを作成できます。この設計機能により、開発者はスムーズに実行できるインタラクティブなアプリケーションを構築できます。
Interpreted− Javaバイトコードはその場でネイティブマシン命令に変換され、どこにも保存されません。リンクは段階的で軽量なプロセスであるため、開発プロセスはより迅速で分析的です。
High Performance − Javaは、ジャストインタイムコンパイラを使用することで、高いパフォーマンスを実現します。
Distributed − Javaは、インターネットの分散環境向けに設計されています。
Dynamic− Javaは、進化する環境に適応するように設計されているため、CやC ++よりも動的であると見なされています。Javaプログラムは、実行時にオブジェクトへのアクセスを検証および解決するために使用できる大量の実行時情報を運ぶことができます。
Javaの歴史
James Goslingは、彼の多くのセットトップボックスプロジェクトの1つで使用するために、1991年6月にJava言語プロジェクトを開始しました。ゴスリングのオフィスの外に立っていた樫の木にちなんで最初は「オーク」と呼ばれていたこの言語も、「グリーン」という名前で呼ばれ、後にランダムな単語のリストからJavaに名前が変更されました。
Sunは1995年にJava1.0として最初のパブリック実装をリリースしました。 Write Once, Run Anywhere (WORA)、人気のあるプラットフォームで無料のランタイムを提供します。
2006年11月13日、Sunは、GNU General Public License(GPL)の条件に基づいて、Javaの多くを無料のオープンソースソフトウェアとしてリリースしました。
2007年5月8日、Sunはプロセスを終了し、Sunが著作権を保有していないコードのごく一部を除いて、Javaのコアコードをすべて無料でオープンソースにしました。
必要なツール
このチュートリアルで説明する例を実行するには、64 MB以上のRAM(128 MBのRAMを推奨)を備えたPentium 200MHzコンピューターが必要です。
次のソフトウェアも必要になります-
- Linux7.1またはWindowsxp / 7/8オペレーティングシステム
- Java JDK 8
- Microsoftメモ帳またはその他のテキストエディタ
このチュートリアルでは、Javaを使用してGUI、ネットワーキング、およびWebアプリケーションを作成するために必要なスキルを提供します。
次は何ですか?
次の章では、Javaとそのドキュメントを入手する方法について説明します。最後に、Javaをインストールし、Javaアプリケーションを開発するための環境を準備する方法について説明します。
この章では、Javaに適した環境をセットアップするさまざまな側面について説明します。
ローカル環境のセットアップ
それでもJavaプログラミング言語用の環境をセットアップする場合は、このセクションで、マシンにJavaをダウンロードしてセットアップする方法について説明します。以下は、環境をセットアップするための手順です。
Java SEは、Javaのダウンロードリンクから無料で入手できます。オペレーティングシステムに基づいたバージョンをダウンロードできます。
指示に従ってJavaをダウンロードし、 .exeマシンにJavaをインストールします。マシンにJavaをインストールしたら、正しいインストールディレクトリを指すように環境変数を設定する必要があります-
Windowsのパスを設定する
Javaをc:\ Program Files \ java \ jdkディレクトリにインストールしたと仮定します-
「マイコンピュータ」を右クリックし、「プロパティ」を選択します。
[詳細設定]タブの下にある[環境変数]ボタンをクリックします。
ここで、「Path」変数を変更して、Java実行可能ファイルへのパスも含まれるようにします。たとえば、パスが現在「C:\ WINDOWS \ SYSTEM32」に設定されている場合は、パスを「C:\ WINDOWS \ SYSTEM32; c:\ ProgramFiles \ java \ jdk \ bin」に変更します。
Linux、UNIX、Solaris、FreeBSDのパスの設定
環境変数PATHは、Javaバイナリがインストールされている場所を指すように設定する必要があります。これを行うのに問題がある場合は、シェルのドキュメントを参照してください。
たとえば、シェルとしてbashを使用する場合は、 '。bashrcの末尾に次の行を追加します。exportPATH= / path / to / java:$ PATH'
人気のあるJavaエディター
Javaプログラムを作成するには、テキストエディタが必要です。市場にはさらに洗練されたIDEがあります。しかし今のところ、あなたは次のいずれかを考えることができます-
Notepad − Windowsマシンでは、メモ帳(このチュートリアルに推奨)、TextPadなどの単純なテキストエディターを使用できます。
Netbeans −オープンソースで無料のJava IDEで、からダウンロードできます。 https://www.netbeans.org/index.html。
Eclipse −Eclipseオープンソースコミュニティによって開発されたJavaIDEで、以下からダウンロードできます。 https://www.eclipse.org/。
次は何ですか?
次の章では、最初のJavaプログラムを作成して実行する方法と、アプリケーションの開発に必要なJavaの重要な基本構文のいくつかについて説明します。
Javaプログラムを考えるとき、それは相互のメソッドを呼び出すことによって通信するオブジェクトのコレクションとして定義できます。ここで、クラス、オブジェクト、メソッド、およびインスタンス変数の意味を簡単に見てみましょう。
Object−オブジェクトには状態と動作があります。例:犬には、色、名前、品種のほか、尻尾を振る、吠える、食べるなどの行動があります。オブジェクトはクラスのインスタンスです。
Class −クラスは、そのタイプのオブジェクトがサポートする動作/状態を説明するテンプレート/ブループリントとして定義できます。
Methods−メソッドは基本的に動作です。クラスには多くのメソッドを含めることができます。これは、ロジックが書き込まれ、データが操作され、すべてのアクションが実行されるメソッド内にあります。
Instance Variables−各オブジェクトには、固有のインスタンス変数のセットがあります。オブジェクトの状態は、これらのインスタンス変数に割り当てられた値によって作成されます。
最初のJavaプログラム
単語を出力する簡単なコードを見てみましょう Hello World。
例
public class MyFirstJavaProgram {
/* This is my first java program.
* This will print 'Hello World' as the output
*/
public static void main(String []args) {
System.out.println("Hello World"); // prints Hello World
}
}
ファイルを保存し、コンパイルし、プログラムを実行する方法を見てみましょう。次の手順に従ってください-
メモ帳を開き、上記のようにコードを追加します。
ファイルをMyFirstJavaProgram.javaとして保存します。
コマンドプロンプトウィンドウを開き、クラスを保存したディレクトリに移動します。C:\だとしましょう。
'javac MyFirstJavaProgram.java'と入力し、Enterキーを押してコードをコンパイルします。コードにエラーがない場合、コマンドプロンプトで次の行に移動します(前提条件:パス変数が設定されています)。
ここで、「java MyFirstJavaProgram」と入力して、プログラムを実行します。
ウィンドウに「HelloWorld」が印刷されているのがわかります。
出力
C:\> javac MyFirstJavaProgram.java
C:\> java MyFirstJavaProgram
Hello World
基本構文
Javaプログラムについては、以下の点に留意することが非常に重要です。
Case Sensitivity − Javaでは大文字と小文字が区別されます。つまり、識別子です。 Hello そして hello Javaでは異なる意味を持ちます。
Class Names−すべてのクラス名について、最初の文字は大文字にする必要があります。クラスの名前を形成するために複数の単語が使用されている場合、各内側の単語の最初の文字は大文字である必要があります。
Example: クラスMyFirstJavaClass
Method Names−すべてのメソッド名は小文字で始める必要があります。メソッドの名前を形成するために複数の単語が使用されている場合、各内側の単語の最初の文字は大文字である必要があります。
Example: public void myMethodName()
Program File Name −プログラムファイルの名前は、クラス名と完全に一致している必要があります。
ファイルを保存するときは、クラス名を使用して保存し(Javaでは大文字と小文字が区別されることに注意してください)、名前の末尾に「.java」を追加する必要があります(ファイル名とクラス名が一致しない場合、プログラムはコンパイルされません) )。
Example:'MyFirstJavaProgram'がクラス名であると想定します。次に、ファイルを「MyFirstJavaProgram.java」として保存する必要があります。
public static void main(String args[]) − Javaプログラムの処理は、すべてのJavaプログラムの必須部分であるmain()メソッドから開始されます。
Java識別子
すべてのJavaコンポーネントには名前が必要です。クラス、変数、およびメソッドに使用される名前は呼び出されますidentifiers。
Javaでは、識別子について覚えておくべきいくつかのポイントがあります。それらは次のとおりです-
すべての識別子は、文字(AからZまたはaからz)、通貨文字($)、またはアンダースコア(_)で始まる必要があります。
最初の文字の後、識別子は文字の任意の組み合わせを持つことができます。
キーワードを識別子として使用することはできません。
最も重要なのは、識別子で大文字と小文字が区別されることです。
正当な識別子の例:年齢、$ salary、_value、__ 1_value。
不正な識別子の例:123abc、-salary。
Java修飾子
他の言語と同様に、修飾子を使用してクラスやメソッドなどを変更することができます。修飾子には2つのカテゴリがあります-
Access Modifiers −デフォルト、パブリック、保護、プライベート
Non-access Modifiers −最終、抽象、strictfp
次のセクションで、修飾子の詳細を調べます。
Java変数
以下はJavaの変数のタイプです-
- ローカル変数
- クラス変数(静的変数)
- インスタンス変数(非静的変数)
Java配列
配列は、同じタイプの複数の変数を格納するオブジェクトです。ただし、配列自体はヒープ上のオブジェクトです。次の章では、宣言、構築、および初期化の方法について説明します。
Java列挙型
列挙型はJava5.0で導入されました。列挙型は、変数がいくつかの事前定義された値の1つを持つように制限します。この列挙リストの値は列挙型と呼ばれます。
列挙型を使用すると、コード内のバグの数を減らすことができます。
たとえば、フレッシュジュースショップのアプリケーションを検討する場合、ガラスのサイズを小、中、大に制限することができます。これにより、小、中、大以外のサイズを誰も注文できないようになります。
例
class FreshJuice {
enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
FreshJuiceSize size;
}
public class FreshJuiceTest {
public static void main(String args[]) {
FreshJuice juice = new FreshJuice();
juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
System.out.println("Size: " + juice.size);
}
}
上記の例では、次の結果が生成されます-
出力
Size: MEDIUM
Note−列挙型は、独自のものとして、またはクラス内で宣言できます。メソッド、変数、コンストラクターも列挙型内で定義できます。
Javaキーワード
次のリストは、Javaで予約されている単語を示しています。これらの予約語は、定数や変数、またはその他の識別子名として使用することはできません。
概要 | 主張する | ブール値 | ブレーク |
バイト | 場合 | キャッチ | char |
クラス | const | 継続する | デフォルト |
行う | ダブル | そうしないと | 列挙型 |
拡張します | 最後の | 最終的に | 浮く |
にとって | 後藤 | もし | 実装 |
インポート | instanceof | int | インターフェース |
長いです | ネイティブ | 新着 | パッケージ |
民間 | 保護 | 公衆 | 戻る |
ショート | 静的 | strictfp | 素晴らしい |
スイッチ | 同期 | この | スロー |
スロー | 一時的 | 試してみてください | ボイド |
揮発性 | 一方 |
Javaでのコメント
Javaは、CおよびC ++と非常によく似た1行および複数行のコメントをサポートします。コメント内で使用可能なすべての文字は、Javaコンパイラによって無視されます。
例
public class MyFirstJavaProgram {
/* This is my first java program.
* This will print 'Hello World' as the output
* This is an example of multi-line comments.
*/
public static void main(String []args) {
// This is an example of single line comment
/* This is also an example of single line comment. */
System.out.println("Hello World");
}
}
出力
Hello World
空白行の使用
おそらくコメント付きの空白のみを含む行は空白行と呼ばれ、Javaはそれを完全に無視します。
継承
Javaでは、クラスはクラスから派生できます。基本的に、新しいクラスを作成する必要があり、ここに必要なコードの一部が含まれているクラスがある場合は、既存のコードから新しいクラスを派生させることができます。
この概念により、新しいクラスでコードを書き直すことなく、既存のクラスのフィールドとメソッドを再利用できます。このシナリオでは、既存のクラスはsuperclass 派生クラスはと呼ばれます subclass。
インターフェイス
Java言語では、インターフェースは、相互に通信する方法に関するオブジェクト間のコントラクトとして定義できます。継承の概念に関しては、インターフェースが重要な役割を果たします。
インターフェイスは、派生クラス(サブクラス)が使用するメソッドを定義します。しかし、メソッドの実装は完全にサブクラス次第です。
次は何ですか?
次のセクションでは、Javaプログラミングのオブジェクトとクラスについて説明します。セッションの終わりに、Javaのオブジェクトとは何か、クラスとは何かについて明確に理解できるようになります。
Javaはオブジェクト指向言語です。オブジェクト指向機能を備えた言語として、Javaは次の基本的な概念をサポートしています。
- Polymorphism
- Inheritance
- Encapsulation
- Abstraction
- Classes
- Objects
- Instance
- Method
- メッセージパッシング
この章では、クラスとオブジェクトの概念について説明します。
Object−オブジェクトには状態と動作があります。例:犬には、色、名前、品種、行動などの状態があり、尻尾を振ったり、吠えたり、食べたりします。オブジェクトはクラスのインスタンスです。
Class −クラスは、そのタイプのオブジェクトがサポートする動作/状態を説明するテンプレート/ブループリントとして定義できます。
Javaのオブジェクト
ここで、オブジェクトとは何かを詳しく見ていきましょう。現実の世界を考えると、車、犬、人間など、身の回りにある多くの物体を見つけることができます。これらの物体にはすべて、状態と動作があります。
犬を考えると、その状態は-名前、品種、色であり、行動は-吠え、尻尾を振って、走っています。
ソフトウェアオブジェクトを実際のオブジェクトと比較すると、それらの特性は非常に似ています。
ソフトウェアオブジェクトにも状態と動作があります。ソフトウェアオブジェクトの状態はフィールドに保存され、動作はメソッドを介して表示されます。
したがって、ソフトウェア開発では、メソッドはオブジェクトの内部状態で動作し、オブジェクト間の通信はメソッドを介して行われます。
Javaのクラス
クラスは、個々のオブジェクトが作成される青写真です。
以下はクラスのサンプルです。
例
public class Dog {
String breed;
int age;
String color;
void barking() {
}
void hungry() {
}
void sleeping() {
}
}
クラスには、次の変数タイプのいずれかを含めることができます。
Local variables−メソッド、コンストラクター、またはブロック内で定義された変数は、ローカル変数と呼ばれます。変数はメソッド内で宣言および初期化され、メソッドが完了すると変数は破棄されます。
Instance variables−インスタンス変数は、クラス内でメソッド外の変数です。これらの変数は、クラスがインスタンス化されるときに初期化されます。インスタンス変数には、その特定のクラスの任意のメソッド、コンストラクター、またはブロック内からアクセスできます。
Class variables −クラス変数は、staticキーワードを使用して、クラス内、メソッド外で宣言された変数です。
クラスには、さまざまな種類のメソッドの値にアクセスするためのメソッドをいくつでも含めることができます。上記の例では、barking()、hungry()、sleeping()がメソッドです。
以下は、Java言語のクラスを調べるときに議論する必要のある重要なトピックのいくつかです。
コンストラクター
クラスについて議論するとき、最も重要なサブトピックの1つはコンストラクターです。すべてのクラスにはコンストラクターがあります。クラスのコンストラクターを明示的に記述しない場合、Javaコンパイラーはそのクラスのデフォルトコンストラクターを構築します。
新しいオブジェクトが作成されるたびに、少なくとも1つのコンストラクターが呼び出されます。コンストラクターの主なルールは、クラスと同じ名前にする必要があるということです。クラスは複数のコンストラクターを持つことができます。
以下はコンストラクターの例です-
例
public class Puppy {
public Puppy() {
}
public Puppy(String name) {
// This constructor has one parameter, name.
}
}
Javaは、クラスのインスタンスを1つだけ作成できるシングルトンクラスもサポートしています。
Note−2種類のコンストラクターがあります。コンストラクターについては、次の章で詳しく説明します。
オブジェクトの作成
前述のように、クラスはオブジェクトの青写真を提供します。つまり、基本的に、オブジェクトはクラスから作成されます。Javaでは、newキーワードを使用して新しいオブジェクトを作成します。
クラスからオブジェクトを作成する場合、3つのステップがあります-
Declaration −オブジェクトタイプの変数名を持つ変数宣言。
Instantiation −'new 'キーワードは、オブジェクトの作成に使用されます。
Initialization−'new 'キーワードの後に、コンストラクターが呼び出されます。この呼び出しは、新しいオブジェクトを初期化します。
以下はオブジェクトの作成例です-
例
public class Puppy {
public Puppy(String name) {
// This constructor has one parameter, name.
System.out.println("Passed Name is :" + name );
}
public static void main(String []args) {
// Following statement would create an object myPuppy
Puppy myPuppy = new Puppy( "tommy" );
}
}
上記のプログラムをコンパイルして実行すると、次の結果が生成されます-
出力
Passed Name is :tommy
インスタンス変数とメソッドへのアクセス
インスタンス変数とメソッドは、作成されたオブジェクトを介してアクセスされます。インスタンス変数にアクセスするには、以下は完全修飾パスです-
/* First create an object */
ObjectReference = new Constructor();
/* Now call a variable as follows */
ObjectReference.variableName;
/* Now you can call a class method as follows */
ObjectReference.MethodName();
例
この例では、クラスのインスタンス変数とメソッドにアクセスする方法について説明します。
public class Puppy {
int puppyAge;
public Puppy(String name) {
// This constructor has one parameter, name.
System.out.println("Name chosen is :" + name );
}
public void setAge( int age ) {
puppyAge = age;
}
public int getAge( ) {
System.out.println("Puppy's age is :" + puppyAge );
return puppyAge;
}
public static void main(String []args) {
/* Object creation */
Puppy myPuppy = new Puppy( "tommy" );
/* Call class method to set puppy's age */
myPuppy.setAge( 2 );
/* Call another class method to get puppy's age */
myPuppy.getAge( );
/* You can access instance variable as follows as well */
System.out.println("Variable Value :" + myPuppy.puppyAge );
}
}
上記のプログラムをコンパイルして実行すると、次の結果が生成されます-
出力
Name chosen is :tommy
Puppy's age is :2
Variable Value :2
ソースファイル宣言ルール
このセクションの最後の部分として、ソースファイルの宣言ルールを見てみましょう。これらのルールは、ソースファイルでクラス、インポートステートメント、およびパッケージステートメントを宣言するときに不可欠です。
ソースファイルごとに存在できるパブリッククラスは1つだけです。
ソースファイルには、複数の非公開クラスを含めることができます。
パブリッククラス名は、ソースファイルの名前でもある必要があります。 .java最後に。例:クラス名がpublic class Employee {}の場合、ソースファイルはEmployee.javaのようになります。
クラスがパッケージ内で定義されている場合、packageステートメントはソースファイルの最初のステートメントである必要があります。
インポートステートメントが存在する場合は、パッケージステートメントとクラス宣言の間に記述する必要があります。パッケージステートメントがない場合は、インポートステートメントをソースファイルの最初の行にする必要があります。
importおよびpackageステートメントは、ソースファイルに存在するすべてのクラスを意味します。ソースファイル内の異なるクラスに異なるインポートおよび/またはパッケージステートメントを宣言することはできません。
クラスにはいくつかのアクセスレベルがあり、さまざまなタイプのクラスがあります。抽象クラス、最終クラスなど。これらすべてについては、アクセス修飾子の章で説明します。
上記のタイプのクラスとは別に、Javaには内部クラスおよび匿名クラスと呼ばれるいくつかの特別なクラスもあります。
Javaパッケージ
簡単に言えば、これはクラスとインターフェイスを分類する方法です。Javaでアプリケーションを開発する場合、何百ものクラスとインターフェースが作成されるため、これらのクラスを分類することは必須であり、作業がはるかに簡単になります。
インポートステートメント
Javaでは、パッケージとクラス名を含む完全修飾名が指定されている場合、コンパイラーはソースコードまたはクラスを簡単に見つけることができます。Importステートメントは、コンパイラーがその特定のクラスを見つけるための適切な場所を指定する方法です。
たとえば、次の行は、ディレクトリjava_installation / java / io-で使用可能なすべてのクラスをロードするようにコンパイラに要求します。
import java.io.*;
簡単なケーススタディ
ケーススタディでは、2つのクラスを作成します。それらはEmployeeとEmployeeTestです。
最初にメモ帳を開き、次のコードを追加します。これはEmployeeクラスであり、クラスはパブリッククラスであることを忘れないでください。ここで、このソースファイルをEmployee.javaという名前で保存します。
Employeeクラスには、名前、年齢、指定、給与の4つのインスタンス変数があります。このクラスには、パラメーターを受け取る明示的に定義されたコンストラクターが1つあります。
例
import java.io.*;
public class Employee {
String name;
int age;
String designation;
double salary;
// This is the constructor of the class Employee
public Employee(String name) {
this.name = name;
}
// Assign the age of the Employee to the variable age.
public void empAge(int empAge) {
age = empAge;
}
/* Assign the designation to the variable designation.*/
public void empDesignation(String empDesig) {
designation = empDesig;
}
/* Assign the salary to the variable salary.*/
public void empSalary(double empSalary) {
salary = empSalary;
}
/* Print the Employee details */
public void printEmployee() {
System.out.println("Name:"+ name );
System.out.println("Age:" + age );
System.out.println("Designation:" + designation );
System.out.println("Salary:" + salary);
}
}
このチュートリアルで前述したように、処理はmainメソッドから始まります。したがって、このEmployeeクラスを実行するには、mainメソッドが必要であり、オブジェクトを作成する必要があります。これらのタスク用に別のクラスを作成します。
以下は、EmployeeTestクラスです。このクラスは、Employeeクラスの2つのインスタンスを作成し、各オブジェクトのメソッドを呼び出して、各変数に値を割り当てます。
次のコードをEmployeeTest.javaファイルに保存します。
import java.io.*;
public class EmployeeTest {
public static void main(String args[]) {
/* Create two objects using constructor */
Employee empOne = new Employee("James Smith");
Employee empTwo = new Employee("Mary Anne");
// Invoking methods for each object created
empOne.empAge(26);
empOne.empDesignation("Senior Software Engineer");
empOne.empSalary(1000);
empOne.printEmployee();
empTwo.empAge(21);
empTwo.empDesignation("Software Engineer");
empTwo.empSalary(500);
empTwo.printEmployee();
}
}
ここで、両方のクラスをコンパイルしてからEmployeeTestを実行し、次のように結果を確認します。
出力
C:\> javac Employee.java
C:\> javac EmployeeTest.java
C:\> java EmployeeTest
Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0
次は何ですか?
次のセッションでは、Javaの基本的なデータ型と、Javaアプリケーションを開発するときにそれらを使用する方法について説明します。
コンストラクターは、オブジェクトの作成時にオブジェクトを初期化します。クラスと同じ名前で、構文的にはメソッドに似ています。ただし、コンストラクターには明示的な戻り値の型はありません。
通常、コンストラクターを使用して、クラスによって定義されたインスタンス変数に初期値を与えるか、完全に形成されたオブジェクトを作成するために必要なその他の起動手順を実行します。
Javaは、すべてのメンバー変数をゼロに初期化するデフォルトのコンストラクターを自動的に提供するため、定義するかどうかに関係なく、すべてのクラスにコンストラクターがあります。ただし、独自のコンストラクターを定義すると、デフォルトのコンストラクターは使用されなくなります。
構文
以下はコンストラクターの構文です-
class ClassName {
ClassName() {
}
}
Javaでは、次の2種類のコンストラクターを使用できます。
- 引数なしコンストラクター
- パラメータ化されたコンストラクタ
引数なしコンストラクター
名前が引数なしを指定しているため、Javaのコンストラクターは代わりにパラメーターを受け入れません。これらのコンストラクターを使用すると、メソッドのインスタンス変数はすべてのオブジェクトの固定値で初期化されます。
例
Public class MyClass {
Int num;
MyClass() {
num = 100;
}
}
次のようにコンストラクタを呼び出してオブジェクトを初期化します
public class ConsDemo {
public static void main(String args[]) {
MyClass t1 = new MyClass();
MyClass t2 = new MyClass();
System.out.println(t1.num + " " + t2.num);
}
}
これにより、次の結果が生成されます
100 100
パラメータ化されたコンストラクタ
ほとんどの場合、1つ以上のパラメーターを受け入れるコンストラクターが必要になります。パラメーターは、メソッドに追加されるのと同じ方法でコンストラクターに追加されます。コンストラクターの名前の後の括弧内でパラメーターを宣言するだけです。
例
コンストラクターを使用する簡単な例を次に示します-
// A simple constructor.
class MyClass {
int x;
// Following is the constructor
MyClass(int i ) {
x = i;
}
}
次のようにコンストラクタを呼び出してオブジェクトを初期化します-
public class ConsDemo {
public static void main(String args[]) {
MyClass t1 = new MyClass( 10 );
MyClass t2 = new MyClass( 20 );
System.out.println(t1.x + " " + t2.x);
}
}
これにより、次の結果が生成されます-
10 20
変数は、値を格納するために予約されたメモリ位置に他なりません。これは、変数を作成するときに、メモリにいくらかのスペースを予約することを意味します。
オペレーティングシステムは、変数のデータ型に基づいてメモリを割り当て、予約済みメモリに何を格納できるかを決定します。したがって、変数にさまざまなデータ型を割り当てることにより、これらの変数に整数、小数、または文字を格納できます。
Javaで利用できるデータ型は2つあります-
- プリミティブデータ型
- 参照/オブジェクトのデータ型
プリミティブデータ型
Javaでサポートされているプリミティブデータ型は8つあります。プリミティブデータ型は言語によって事前定義され、キーワードによって名前が付けられます。ここで、8つのプリミティブデータ型について詳しく見ていきましょう。
バイト
バイトデータ型は、8ビットの符号付き2の補数整数です。
最小値は-128(-2 ^ 7)です
最大値は127(両端を含む)(2 ^ 7 -1)
デフォルト値は0です
バイトは整数の4分の1であるため、バイトデータ型は、主に整数の代わりに、大きな配列のスペースを節約するために使用されます。
例:バイトa = 100、バイトb = -50
ショート
短いデータ型は、16ビットの符号付き2の補数整数です。
最小値は-32,768(-2 ^ 15)
最大値は32,767(両端を含む)(2 ^ 15 -1)
短いデータ型を使用して、メモリをバイトデータ型として保存することもできます。ショートは整数の2分の1です
デフォルト値は0です。
例:short s = 10000、short r = -20000
int
Intデータ型は、32ビットの符号付き2の補数整数です。
最小値は-2,147,483,648(-2 ^ 31)
最大値は2,147,483,647(両端を含む)(2 ^ 31 -1)
メモリに関する懸念がない限り、整数は通常、整数値のデフォルトのデータ型として使用されます。
デフォルト値は0です
例:int a = 100000、int b = -200000
長いです
- 長いデータ型は、64ビットの符号付き2の補数整数です。
- 最小値は-9,223,372,036,854,775,808(-2 ^ 63)です
- 最大値は9,223,372,036,854,775,807(両端を含む)(2 ^ 63-1)
- このタイプは、intよりも広い範囲が必要な場合に使用されます
- デフォルト値は0Lです
- 例:long a = 100000L、long b = -200000L
浮く
浮動小数点データ型は、単精度32ビットIEEE754浮動小数点です。
Floatは主に、浮動小数点数の大きな配列でメモリを節約するために使用されます
デフォルト値は0.0fです
フロートデータ型は、通貨などの正確な値には使用されません。
例:float f1 = 234.5f
ダブル
doubleデータ型は、倍精度64ビットIEEE754浮動小数点です。
このデータ型は通常、10進値のデフォルトのデータ型として使用され、通常はデフォルトの選択です。
通貨などの正確な値には、doubleデータ型を使用しないでください。
デフォルト値は0.0dです
例:double d1 = 123.4
ブール値
- ブールデータ型は1ビットの情報を表します
- 可能な値はtrueとfalseの2つだけです。
- このデータ型は、真/偽の状態を追跡する単純なフラグに使用されます
- デフォルト値はfalseです
- 例:boolean one = true
char
- charデータ型は単一の16ビットUnicode文字です
- 最小値は '\ u0000'(または0)です
- 最大値は '\ uffff'(または65,535を含む)です
- 文字データ型は、任意の文字を格納するために使用されます
- 例:char letterA = 'A'
参照データ型
参照変数は、クラスの定義済みコンストラクターを使用して作成されます。それらはオブジェクトにアクセスするために使用されます。これらの変数は、変更できない特定のタイプであると宣言されています。たとえば、従業員、子犬など。
クラスオブジェクトとさまざまなタイプの配列変数は、参照データ型に分類されます。
参照変数のデフォルト値はnullです。
参照変数は、宣言された型または互換性のある型の任意のオブジェクトを参照するために使用できます。
例:動物動物= new Animal( "giraffe");
Javaリテラル
リテラルは、固定値のソースコード表現です。それらは、計算なしでコードに直接表されます。
リテラルは、任意のプリミティブ型変数に割り当てることができます。例-
byte a = 68;
char a = 'A';
byte、int、long、およびshortは、10進数(基数10)、16進数(基数16)、または8進数(基数8)の数値システムでも表すことができます。
リテラルにこれらの数値システムを使用する場合、接頭辞0は8進数を示すために使用され、接頭辞0xは16進数を示します。例-
int decimal = 100;
int octal = 0144;
int hexa = 0x64;
Javaの文字列リテラルは、他のほとんどの言語と同じように、文字のシーケンスを二重引用符のペアで囲むことによって指定されます。文字列リテラルの例は次のとおりです。
例
"Hello World"
"two\nlines"
"\"This is in quotes\""
文字列および文字タイプのリテラルには、任意のUnicode文字を含めることができます。例-
char a = '\u0001';
String a = "\u0001";
Java言語は、Stringおよびcharリテラルのいくつかの特別なエスケープシーケンスもサポートしています。彼らは-
表記 | 表現された文字 |
---|---|
\ n | 改行(0x0a) |
\ r | キャリッジリターン(0x0d) |
\ f | 改ページ(0x0c) |
\ b | バックスペース(0x08) |
\ s | スペース(0x20) |
\ t | タブ |
\ " | 二重引用符 |
\ ' | 一重引用符 |
\\ | バックスラッシュ |
\ ddd | 8進数(ddd) |
\ uxxxx | 16進数のUNICODE文字(xxxx) |
次は何ですか?
この章では、さまざまなデータ型について説明しました。次のトピックでは、さまざまな変数タイプとその使用法について説明します。これにより、Javaクラスやインターフェースなどでそれらをどのように使用できるかをよく理解できます。
変数は、プログラムが操作できる名前付きストレージを提供します。Javaの各変数には特定のタイプがあり、変数のメモリのサイズとレイアウトを決定します。そのメモリ内に保存できる値の範囲。変数に適用できる一連の操作。
使用する前に、すべての変数を宣言する必要があります。以下は、変数宣言の基本的な形式です。
data type variable [ = value][, variable [ = value] ...] ;
ここで、データ型はJavaのデータ型の1つであり、変数は変数の名前です。指定されたタイプの複数の変数を宣言するには、コンマ区切りのリストを使用できます。
以下は、Javaでの変数宣言と初期化の有効な例です。
例
int a, b, c; // Declares three ints, a, b, and c.
int a = 10, b = 10; // Example of initialization
byte B = 22; // initializes a byte type variable B.
double pi = 3.14159; // declares and assigns a value of PI.
char a = 'A'; // the char variable a iis initialized with value 'a'
この章では、Java言語で使用できるさまざまな変数タイプについて説明します。Javaには3種類の変数があります-
- ローカル変数
- インスタンス変数
- クラス/静的変数
ローカル変数
ローカル変数は、メソッド、コンストラクター、またはブロックで宣言されます。
ローカル変数は、メソッド、コンストラクター、またはブロックに入ると作成され、メソッド、コンストラクター、またはブロックを出ると変数は破棄されます。
アクセス修飾子はローカル変数には使用できません。
ローカル変数は、宣言されたメソッド、コンストラクター、またはブロック内でのみ表示されます。
ローカル変数は、内部的にスタックレベルで実装されます。
ローカル変数にはデフォルト値がないため、最初に使用する前にローカル変数を宣言し、初期値を割り当てる必要があります。
例
ここで、年齢はローカル変数です。これはpupAge()メソッド内で定義され、そのスコープはこのメソッドのみに制限されます。
public class Test {
public void pupAge() {
int age = 0;
age = age + 7;
System.out.println("Puppy age is : " + age);
}
public static void main(String args[]) {
Test test = new Test();
test.pupAge();
}
}
これにより、次の結果が生成されます-
出力
Puppy age is: 7
例
次の例では、ageを初期化せずに使用しているため、コンパイル時にエラーが発生します。
public class Test {
public void pupAge() {
int age;
age = age + 7;
System.out.println("Puppy age is : " + age);
}
public static void main(String args[]) {
Test test = new Test();
test.pupAge();
}
}
これにより、コンパイル中に次のエラーが発生します-
出力
Test.java:4:variable number might not have been initialized
age = age + 7;
^
1 error
インスタンス変数
インスタンス変数はクラス内で宣言されますが、メソッド、コンストラクター、または任意のブロックの外部で宣言されます。
ヒープ内のオブジェクトにスペースが割り当てられると、各インスタンス変数値のスロットが作成されます。
インスタンス変数は、キーワード「new」を使用してオブジェクトが作成されるときに作成され、オブジェクトが破棄されると破棄されます。
インスタンス変数は、複数のメソッド、コンストラクター、ブロック、またはクラス全体に存在する必要があるオブジェクトの状態の重要な部分によって参照される必要がある値を保持します。
インスタンス変数は、使用前または使用後にクラスレベルで宣言できます。
インスタンス変数にアクセス修飾子を指定できます。
インスタンス変数は、クラス内のすべてのメソッド、コンストラクター、およびブロックで表示されます。通常、これらの変数をプライベート(アクセスレベル)にすることをお勧めします。ただし、アクセス修飾子を使用して、これらの変数にサブクラスの可視性を与えることができます。
インスタンス変数にはデフォルト値があります。数値の場合、デフォルト値は0、ブール値の場合はfalse、オブジェクト参照の場合はnullです。値は、宣言中またはコンストラクター内で割り当てることができます。
クラス内で変数名を呼び出すことにより、インスタンス変数に直接アクセスできます。ただし、静的メソッド内(インスタンス変数にアクセシビリティが与えられている場合)では、完全修飾名を使用して呼び出す必要があります。ObjectReference.VariableName。
例
import java.io.*;
public class Employee {
// this instance variable is visible for any child class.
public String name;
// salary variable is visible in Employee class only.
private double salary;
// The name variable is assigned in the constructor.
public Employee (String empName) {
name = empName;
}
// The salary variable is assigned a value.
public void setSalary(double empSal) {
salary = empSal;
}
// This method prints the employee details.
public void printEmp() {
System.out.println("name : " + name );
System.out.println("salary :" + salary);
}
public static void main(String args[]) {
Employee empOne = new Employee("Ransika");
empOne.setSalary(1000);
empOne.printEmp();
}
}
これにより、次の結果が生成されます-
出力
name : Ransika
salary :1000.0
クラス/静的変数
静的変数とも呼ばれるクラス変数は、クラス内でstaticキーワードを使用して宣言されますが、メソッド、コンストラクター、またはブロックの外部にあります。
作成されるオブジェクトの数に関係なく、クラスごとに各クラス変数のコピーは1つだけです。
静的変数は、定数として宣言される以外に使用されることはめったにありません。定数は、public / private、final、およびstaticとして宣言される変数です。定数変数は初期値から変更されることはありません。
静的変数は静的メモリに保存されます。finalとして宣言され、パブリック定数またはプライベート定数として使用される以外の静的変数を使用することはめったにありません。
静的変数は、プログラムの開始時に作成され、プログラムの停止時に破棄されます。
可視性はインスタンス変数に似ています。ただし、ほとんどの静的変数は、クラスのユーザーが使用できる必要があるため、パブリックとして宣言されています。
デフォルト値はインスタンス変数と同じです。数値の場合、デフォルト値は0です。ブール値の場合、これはfalseです。オブジェクト参照の場合はnullです。値は、宣言中またはコンストラクター内で割り当てることができます。さらに、値は特別な静的初期化ブロックに割り当てることができます。
静的変数には、クラス名ClassName.VariableNameで呼び出すことでアクセスできます。
クラス変数をpublicstatic finalとして宣言する場合、変数名(定数)はすべて大文字になります。静的変数がパブリック変数およびファイナル変数でない場合、命名構文はインスタンス変数およびローカル変数と同じです。
例
import java.io.*;
public class Employee {
// salary variable is a private static variable
private static double salary;
// DEPARTMENT is a constant
public static final String DEPARTMENT = "Development ";
public static void main(String args[]) {
salary = 1000;
System.out.println(DEPARTMENT + "average salary:" + salary);
}
}
これにより、次の結果が生成されます-
出力
Development average salary:1000
Note −変数が外部クラスからアクセスされる場合、定数はEmployee.DEPARTMENTとしてアクセスされる必要があります
次は何ですか?
この章では、すでにアクセス修飾子(パブリックおよびプライベート)を使用しています。次の章では、アクセス修飾子と非アクセス修飾子について詳しく説明します。
修飾子は、それらの定義に追加して意味を変更するキーワードです。Java言語には、次のようなさまざまな修飾子があります。
Javaアクセス修飾子
非アクセス修飾子
修飾子を使用するには、クラス、メソッド、または変数の定義にそのキーワードを含めます。次の例のように、修飾子はステートメントの残りの部分の前にあります。
例
public class className {
// ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
// body of method
}
アクセス制御修飾子
Javaには、クラス、変数、メソッド、およびコンストラクターのアクセスレベルを設定するための多数のアクセス修飾子が用意されています。4つのアクセスレベルは次のとおりです。
- パッケージに表示されます。デフォルトです。修飾子は必要ありません。
- クラスのみに表示されます(プライベート)。
- 世界に見える(公開)。
- パッケージとすべてのサブクラスに表示されます(保護されています)。
非アクセス修飾子
Javaは、他の多くの機能を実現するために、アクセス以外の修飾子をいくつか提供しています。
クラスメソッドと変数を作成するための静的修飾子。
クラス、メソッド、および変数の実装を確定するための最終修飾子。
抽象クラスとメソッドを作成するための抽象修飾子。
同期および揮発性のスレッドに使用されている修飾、。
次は何ですか?
次のセクションでは、Java言語で使用される基本的な演算子について説明します。この章では、アプリケーション開発中にこれらの演算子を使用する方法の概要を説明します。
Javaには、変数を操作するための豊富な演算子セットが用意されています。すべてのJava演算子を次のグループに分けることができます-
- 算術演算子
- 関係演算子
- ビット演算子
- 論理演算子
- 代入演算子
- その他の演算子
算術演算子
算術演算子は、代数で使用されるのと同じ方法で数式で使用されます。次の表に、算術演算子-を示します。
整数変数Aが10を保持し、変数Bが20を保持すると仮定すると、-
例を表示
オペレーター | 説明 | 例 |
---|---|---|
+(追加) | 演算子のいずれかの側に値を追加します。 | A + Bは30を与えます |
-(減算) | 左側のオペランドから右側のオペランドを減算します。 | A-Bは-10を与えます |
*(乗算) | 演算子のいずれかの側で値を乗算します。 | A * Bは200を与えます |
/(除算) | 左側のオペランドを右側のオペランドで除算します。 | B / Aは2を与えます |
% (係数) | 左側のオペランドを右側のオペランドで除算し、余りを返します。 | B%Aは0を与えます |
++(インクリメント) | オペランドの値を1増やします。 | B ++は21を与えます |
-(デクリメント) | オペランドの値を1つ減らします。 | B--は19を与える |
関係演算子
Java言語でサポートされている関係演算子は次のとおりです。
変数Aが10を保持し、変数Bが20を保持すると仮定すると、-
例を表示
オペレーター | 説明 | 例 |
---|---|---|
==(等しい) | 2つのオペランドの値が等しいかどうかをチェックし、等しい場合は条件が真になります。 | (A == B)は真ではありません。 |
!=(等しくない) | 2つのオペランドの値が等しいかどうかをチェックし、値が等しくない場合は条件が真になります。 | (A!= B)は真です。 |
>(より大きい) | 左のオペランドの値が右のオペランドの値より大きいかどうかを確認します。大きい場合は、条件が真になります。 | (A> B)は正しくありません。 |
<(未満) | 左のオペランドの値が右のオペランドの値よりも小さいかどうかを確認します。小さい場合は、条件が真になります。 | (A <B)は真です。 |
> =(以上) | 左のオペランドの値が右のオペランドの値以上であるかどうかをチェックします。はいの場合、条件は真になります。 | (A> = B)は正しくありません。 |
<=(以下) | 左のオペランドの値が右のオペランドの値以下であるかどうかをチェックします。はいの場合、条件は真になります。 | (A <= B)は真です。 |
ビット演算子
Javaは、整数型、long、int、short、char、およびbyteに適用できるいくつかのビット演算子を定義しています。
ビット単位の演算子はビットを処理し、ビットごとの演算を実行します。a = 60およびb = 13であると仮定します。現在、バイナリ形式では次のようになります-
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a | b = 0011 1101
a ^ b = 0011 0001
〜a = 1100 0011
次の表に、ビット演算子-を示します。
整数変数Aが60を保持し、変数Bが13を保持すると仮定すると、-
例を表示
オペレーター | 説明 | 例 |
---|---|---|
&(ビット単位および) | バイナリAND演算子は、両方のオペランドに存在する場合、結果にビットをコピーします。 | (A&B)は00001100である12を与えます |
| (ビット単位または) | バイナリOR演算子は、いずれかのオペランドに存在する場合、ビットをコピーします。 | (A | B)は611 1101である61を与えます |
^(ビット単位のXOR) | バイナリXOR演算子は、ビットが両方ではなく一方のオペランドに設定されている場合、そのビットをコピーします。 | (A ^ B)は、00110001である49を与えます。 |
〜(ビット単位の褒め言葉) | Binary Ones Complement Operatorは単項であり、ビットを「反転」させる効果があります。 | (〜A)は、符号付き2進数のため、2の補数形式で11000011である-61を返します。 |
<<(左シフト) | バイナリ左シフト演算子。左のオペランドの値は、右のオペランドで指定されたビット数だけ左に移動します。 | << 2は、11110000である240を与えます |
>>(右シフト) | バイナリ右シフト演算子。左のオペランドの値は、右のオペランドで指定されたビット数だけ右に移動します。 | >> 2は1111である15を与えます |
>>>(ゼロフィル右シフト) | 右シフトゼロフィル演算子。左のオペランドの値は、右のオペランドで指定されたビット数だけ右に移動し、シフトされた値はゼロで埋められます。 | >>> 2は、00001111である15を与えます |
論理演算子
次の表に、論理演算子-を示します。
ブール変数Aがtrueを保持し、変数Bがfalseを保持すると仮定すると、−
例を表示
オペレーター | 説明 | 例 |
---|---|---|
&&(論理積) | 論理AND演算子と呼ばれます。両方のオペランドがゼロ以外の場合、条件は真になります。 | (A && B)は誤りです |
|| (論理または) | 論理OR演算子と呼ばれます。2つのオペランドのいずれかがゼロ以外の場合、条件は真になります。 | (A || B)は真です |
!(論理的ではない) | 論理NOT演算子と呼ばれます。オペランドの論理状態を逆にするために使用します。条件がtrueの場合、LogicalNOT演算子はfalseになります。 | !(A && B)はtrueです |
代入演算子
以下は、Java言語でサポートされている代入演算子です-
例を表示
オペレーター | 説明 | 例 |
---|---|---|
= | 単純な代入演算子。右側のオペランドから左側のオペランドに値を割り当てます。 | C = A + Bは、A + Bの値をCに割り当てます |
+ = | AND代入演算子を追加します。右のオペランドを左のオペランドに追加し、結果を左のオペランドに割り当てます。 | C + = AはC = C + Aと同等です |
-= | AND代入演算子を減算します。左のオペランドから右のオペランドを減算し、その結果を左のオペランドに割り当てます。 | C- = AはC = C –Aと同等です |
* = | AND代入演算子を乗算します。右のオペランドと左のオペランドを乗算し、その結果を左のオペランドに割り当てます。 | C * = AはC = C * Aと同等です |
/ = | AND代入演算子を除算します。左のオペランドを右のオペランドで除算し、その結果を左のオペランドに割り当てます。 | C / = AはC = C / Aと同等です |
%= | モジュラスAND代入演算子。2つのオペランドを使用してモジュラスを取り、その結果を左のオペランドに割り当てます。 | C%= AはC = C%Aと同等です |
<< = | 左シフトAND代入演算子。 | C << = 2はC = C << 2と同じです |
>> = | 右シフトAND代入演算子。 | C >> = 2はC = C >> 2と同じです |
&= | ビットごとのAND代入演算子。 | C&= 2はC = C&2と同じです |
^ = | ビット単位の排他的論理和と代入演算子。 | C ^ = 2はC = C ^ 2と同じです |
| = | ビット単位の包括的ORおよび代入演算子。 | C | = 2はC = C |と同じです 2 |
その他の演算子
Java言語でサポートされている他の演算子はほとんどありません。
条件付き演算子(?:)
条件演算子は、 ternary operator。この演算子は3つのオペランドで構成され、ブール式を評価するために使用されます。演算子の目的は、変数に割り当てる値を決定することです。演算子は次のように記述されます-
variable x = (expression) ? value if true : value if false
以下は例です-
Example
public class Test {
public static void main(String args[]) {
int a, b;
a = 10;
b = (a == 1) ? 20: 30;
System.out.println( "Value of b is : " + b );
b = (a == 10) ? 20: 30;
System.out.println( "Value of b is : " + b );
}
}
これにより、次の結果が生成されます-
Output
Value of b is : 30
Value of b is : 20
instanceof演算子
この演算子は、オブジェクト参照変数にのみ使用されます。オペレーターは、オブジェクトが特定のタイプ(クラスタイプまたはインターフェイスタイプ)であるかどうかを確認します。instanceof演算子は次のように記述されます-
( Object reference variable ) instanceof (class/interface type)
演算子の左側の変数によって参照されるオブジェクトが、右側のクラス/インターフェイスタイプのIS-Aチェックに合格した場合、結果はtrueになります。以下は例です-
Example
public class Test {
public static void main(String args[]) {
String name = "James";
// following will return true since name is type of String
boolean result = name instanceof String;
System.out.println( result );
}
}
これにより、次の結果が生成されます-
Output
true
比較されるオブジェクトが右側のタイプと互換性のある割り当てである場合、この演算子は引き続きtrueを返します。以下はもう1つの例です-
Example
class Vehicle {}
public class Car extends Vehicle {
public static void main(String args[]) {
Vehicle a = new Car();
boolean result = a instanceof Car;
System.out.println( result );
}
}
これにより、次の結果が生成されます-
Output
true
Java演算子の優先順位
演算子の優先順位は、式内の用語のグループ化を決定します。これは、式の評価方法に影響します。特定の演算子は他の演算子よりも優先されます。たとえば、乗算演算子は加算演算子よりも優先されます-
たとえば、x = 7 + 3 * 2; ここで、演算子*は+よりも優先されるため、xには20ではなく13が割り当てられます。したがって、最初に3 * 2が乗算され、次に7に加算されます。
ここでは、優先順位が最も高い演算子がテーブルの上部に表示され、優先順位が最も低い演算子が下部に表示されます。式内では、優先順位の高い演算子が最初に評価されます。
カテゴリー | オペレーター | 結合性 |
---|---|---|
Postfix | 式++式- | 左から右へ |
単項 | ++式-式+式–式〜! | 右から左へ |
乗法 | * /% | 左から右へ |
添加剤 | +- | 左から右へ |
シフト | << >> >>> | 左から右へ |
関連した | <> <=> = instanceof | 左から右へ |
平等 | ==!= | 左から右へ |
ビットごとのAND | & | 左から右へ |
ビット単位のXOR | ^ | 左から右へ |
ビットごとのOR | | | 左から右へ |
論理積 | && | 左から右へ |
論理OR | || | 左から右へ |
条件付き | ?: | 右から左へ |
割り当て | = + =-= * = / =%= ^ = | = << = >> = >>> = | 右から左へ |
次は何ですか?
次の章では、Javaプログラミングのループ制御について説明します。この章では、さまざまなタイプのループと、これらのループをJavaプログラム開発で使用する方法、およびそれらが使用されている目的について説明します。
コードのブロックを数回実行する必要がある場合があります。一般に、ステートメントは順番に実行されます。関数の最初のステートメントが最初に実行され、次に2番目のステートメントが実行されます。
プログラミング言語は、より複雑な実行パスを可能にするさまざまな制御構造を提供します。
A loop ステートメントを使用すると、ステートメントまたはステートメントのグループを複数回実行できます。以下は、ほとんどのプログラミング言語でのループステートメントの一般的な形式です。
Javaプログラミング言語は、ループ要件を処理するために次のタイプのループを提供します。詳細を確認するには、次のリンクをクリックしてください。
シニア番号 | ループと説明 |
---|---|
1 | whileループ 指定された条件が真である間、ステートメントまたはステートメントのグループを繰り返します。ループ本体を実行する前に条件をテストします。 |
2 | forループ 一連のステートメントを複数回実行し、ループ変数を管理するコードを省略します。 |
3 | do ... whileループ whileステートメントと同様ですが、ループ本体の最後で条件をテストする点が異なります。 |
ループ制御ステートメント
ループ制御ステートメントは、実行を通常のシーケンスから変更します。実行がスコープを離れると、そのスコープで作成されたすべての自動オブジェクトが破棄されます。
Javaは、次の制御ステートメントをサポートしています。詳細を確認するには、次のリンクをクリックしてください。
シニア番号 | 制御ステートメントと説明 |
---|---|
1 | breakステートメント を終了します loop または switch ステートメントを実行し、ループまたはスイッチの直後のステートメントに実行を転送します。 |
2 | ステートメントを続ける ループに本体の残りの部分をスキップさせ、繰り返す前にすぐにその状態を再テストします。 |
Javaで拡張されたforループ
Java 5の時点で、拡張forループが導入されました。これは主に、配列を含む要素のコレクションをトラバースするために使用されます。
構文
以下は、拡張forループの構文です。
for(declaration : expression) {
// Statements
}
Declaration−新しく宣言されたブロック変数は、アクセスしている配列の要素と互換性のあるタイプです。変数はforブロック内で使用可能になり、その値は現在の配列要素と同じになります。
Expression−これは、ループする必要のある配列に評価されます。式は、配列変数または配列を返すメソッド呼び出しにすることができます。
例
public class Test {
public static void main(String args[]) {
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
System.out.print( x );
System.out.print(",");
}
System.out.print("\n");
String [] names = {"James", "Larry", "Tom", "Lacy"};
for( String name : names ) {
System.out.print( name );
System.out.print(",");
}
}
}
これにより、次の結果が生成されます-
出力
10, 20, 30, 40, 50,
James, Larry, Tom, Lacy,
次は何ですか?
次の章では、Javaプログラミングの意思決定ステートメントについて学習します。
意思決定構造には、プログラムによって評価またはテストされる1つ以上の条件と、条件が真であると判断された場合に実行される1つまたは複数のステートメント、およびオプションで、条件が判断された場合に実行される他のステートメントがあります。偽りである。
以下は、ほとんどのプログラミング言語に見られる典型的な意思決定構造の一般的な形式です。
Javaプログラミング言語は、次のタイプの意思決定ステートメントを提供します。詳細を確認するには、次のリンクをクリックしてください。
シニア番号 | ステートメントと説明 |
---|---|
1 | ifステートメント アン if statement ブール式とそれに続く1つ以上のステートメントで構成されます。 |
2 | if ... elseステートメント アン if statement オプションの後に続くことができます else statement、ブール式がfalseの場合に実行されます。 |
3 | ネストされたifステートメント あなたは1つを使用することができます if または else if 別の内部のステートメント if または else if ステートメント。 |
4 | switchステートメント A switch ステートメントを使用すると、値のリストに対して変数が等しいかどうかをテストできます。 |
?:オペレーター
カバーしました conditional operator ? : 置き換えるために使用できる前の章で if...elseステートメント。それは次の一般的な形式を持っています-
Exp1 ? Exp2 : Exp3;
ここで、Exp1、Exp2、およびExp3は式です。コロンの使用と配置に注意してください。
式全体の値を決定するために、最初にexp1が評価されます。
exp1の値がtrueの場合、Exp2の値は式全体の値になります。
exp1の値がfalseの場合、Exp3が評価され、その値が式全体の値になります。
次は何ですか?
次の章では、(java.langパッケージ内の)NumberクラスとJava言語でのそのサブクラスについて説明します。
プリミティブデータ型ではなく、これらのクラスのインスタンス化を使用する状況のいくつかと、Numbersを操作するときに知っておく必要のある書式設定や数学関数などのクラスについて検討します。
通常、Numbersを操作するときは、byte、int、long、doubleなどのプリミティブデータ型を使用します。
例
int i = 5000;
float gpa = 13.65f;
double mask = 125;
ただし、開発では、プリミティブデータ型の代わりにオブジェクトを使用する必要がある状況に遭遇します。これを達成するために、Javaはwrapper classes。
すべてのラッパークラス(Integer、Long、Byte、Double、Float、Short)は、抽象クラスNumberのサブクラスです。
ラッパークラスのオブジェクトには、それぞれのプリミティブデータ型が含まれるかラップされます。プリミティブデータ型をオブジェクトに変換することを呼びますboxing、これはコンパイラによって処理されます。したがって、ラッパークラスを使用している間は、プリミティブデータ型の値をWrapperクラスのコンストラクターに渡す必要があります。
また、ラッパーオブジェクトはプリミティブデータ型に変換され、このプロセスはボックス化解除と呼ばれます。ザ・Number クラスはjava.langパッケージの一部です。
以下はボクシングとボックス化解除の例です-
例
public class Test {
public static void main(String args[]) {
Integer x = 5; // boxes int to an Integer object
x = x + 10; // unboxes the Integer to a int
System.out.println(x);
}
}
これにより、次の結果が生成されます-
出力
15
xに整数値が割り当てられると、xは整数オブジェクトであるため、コンパイラは整数をボックス化します。後で、xはボックス化されていないため、整数として追加できます。
数値メソッド
以下は、Numberクラスのすべてのサブクラスが実装するインスタンスメソッドのリストです。
シニア番号 | 方法と説明 |
---|---|
1 | xxxValue() このNumberオブジェクトの値をxxxデータ型に変換して返します。 |
2 | compareTo() このNumberオブジェクトを引数と比較します。 |
3 | equals() この数値オブジェクトが引数と等しいかどうかを判別します。 |
4 | valueOf() 指定されたプリミティブの値を保持する整数オブジェクトを返します。 |
5 | toString() 指定されたintまたはIntegerの値を表すStringオブジェクトを返します。 |
6 | parseInt() このメソッドは、特定の文字列のプリミティブデータ型を取得するために使用されます。 |
7 | abs() 引数の絶対値を返します。 |
8 | ceil() 引数以上の最小の整数を返します。ダブルとして返されます。 |
9 | 床() 引数以下の最大の整数を返します。ダブルとして返されます。 |
10 | rint() 引数に値が最も近い整数を返します。ダブルとして返されます。 |
11 | 円形() メソッドの引数への戻り値の型で示されるように、最も近いlongまたはintを返します。 |
12 | min() 2つの引数のうち小さい方を返します。 |
13 | max() 2つの引数のうち大きい方を返します。 |
14 | exp() 自然対数の底eを引数の累乗に戻します。 |
15 | ログ() 引数の自然対数を返します。 |
16 | 捕虜() 最初の引数の値を2番目の引数の累乗で返します。 |
17 | sqrt() 引数の平方根を返します。 |
18 | 罪() 指定されたdouble値の正弦を返します。 |
19 | cos() 指定されたdouble値のコサインを返します。 |
20 | tan() 指定されたdouble値のタンジェントを返します。 |
21 | asin() 指定されたdouble値のアークサインを返します。 |
22 | acos() 指定されたdouble値のアークコサインを返します。 |
23 | 日焼け() 指定されたdouble値のアークタンジェントを返します。 |
24 | atan2() 直交座標(x、y)を極座標(r、シータ)に変換し、シータを返します。 |
25 | toDegrees() 引数を度に変換します。 |
26 | toRadians() 引数をラジアンに変換します。 |
27 | ランダム() 乱数を返します。 |
次は何ですか?
次のセクションでは、JavaのCharacterクラスについて説明します。Javaでオブジェクト文字とプリミティブデータ型charを使用する方法を学習します。
通常、文字を操作するときは、プリミティブデータ型charを使用します。
例
char ch = 'a';
// Unicode for uppercase Greek omega character
char uniChar = '\u039A';
// an array of chars
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };
ただし、開発では、プリミティブデータ型の代わりにオブジェクトを使用する必要がある状況に遭遇します。これを実現するために、Javaはラッパークラスを提供しますCharacter プリミティブデータ型charの場合。
Characterクラスは、文字を操作するための便利なクラス(つまり、静的)メソッドをいくつか提供します。Characterコンストラクターを使用してCharacterオブジェクトを作成できます-
Character ch = new Character('a');
Javaコンパイラは、状況によってはCharacterオブジェクトも作成します。たとえば、オブジェクトを期待するメソッドにプリミティブcharを渡すと、コンパイラは自動的にcharを文字に変換します。この機能は、変換が逆の場合、自動ボックス化またはボックス化解除と呼ばれます。
例
// Here following primitive char 'a'
// is boxed into the Character object ch
Character ch = 'a';
// Here primitive 'x' is boxed for method test,
// return is unboxed to char 'c'
char c = test('x');
エスケープシーケンス
バックスラッシュ(\)が前に付いている文字はエスケープシーケンスであり、コンパイラにとって特別な意味があります。
改行文字(\ n)は、このチュートリアルのSystem.out.println()ステートメントで頻繁に使用され、文字列が出力された後に次の行に進みます。
次の表は、Javaエスケープシーケンスを示しています-
エスケープシーケンス | 説明 |
---|---|
\ t | この時点でテキストにタブを挿入します。 |
\ b | この時点でテキストにバックスペースを挿入します。 |
\ n | この時点でテキストに改行を挿入します。 |
\ r | この時点で、テキストにキャリッジリターンを挿入します。 |
\ f | この時点でテキストにフォームフィードを挿入します。 |
\ ' | この時点で、テキストに一重引用符を挿入します。 |
\ " | この時点で、テキストに二重引用符を挿入します。 |
\\ | この時点で、テキストに円記号を挿入します。 |
printステートメントでエスケープシーケンスが検出されると、コンパイラはそれに応じてそれを解釈します。
例
引用符を引用符の中に入れたい場合は、内部引用符にエスケープシーケンス\ "を使用する必要があります-
public class Test {
public static void main(String args[]) {
System.out.println("She said \"Hello!\" to me.");
}
}
これにより、次の結果が生成されます-
出力
She said "Hello!" to me.
文字メソッド
以下は、Characterクラスのすべてのサブクラスが実装する重要なインスタンスメソッドのリストです。
シニア番号 | 方法と説明 |
---|---|
1 | isLetter() 指定されたchar値が文字であるかどうかを判別します。 |
2 | isDigit() 指定されたchar値が数字であるかどうかを判別します。 |
3 | isWhitespace() 指定されたchar値が空白であるかどうかを判別します。 |
4 | isUpperCase() 指定されたchar値が大文字かどうかを判別します。 |
5 | isLowerCase() 指定されたchar値が小文字であるかどうかを判別します。 |
6 | toUpperCase() 指定されたchar値の大文字を返します。 |
7 | toLowerCase() 指定されたchar値の小文字を返します。 |
8 | toString() 指定された文字値、つまり1文字の文字列を表すStringオブジェクトを返します。 |
メソッドの完全なリストについては、java.lang.CharacterAPI仕様を参照してください。
次は何ですか?
次のセクションでは、JavaのStringクラスについて説明します。文字列を効率的に宣言して使用する方法と、文字列クラスの重要なメソッドのいくつかを学習します。
Javaプログラミングで広く使用されている文字列は、文字のシーケンスです。Javaプログラミング言語では、文字列はオブジェクトとして扱われます。
Javaプラットフォームは、文字列を作成および操作するためのStringクラスを提供します。
文字列の作成
文字列を作成する最も直接的な方法は、次のように書くことです。
String greeting = "Hello world!";
コード内で文字列リテラルを検出すると、コンパイラはその値(この場合は「Helloworld!」)を使用してStringオブジェクトを作成します。
他のオブジェクトと同様に、newキーワードとコンストラクターを使用してStringオブジェクトを作成できます。Stringクラスには11個のコンストラクターがあり、文字の配列など、さまざまなソースを使用して文字列の初期値を提供できます。
例
public class StringDemo {
public static void main(String args[]) {
char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };
String helloString = new String(helloArray);
System.out.println( helloString );
}
}
これにより、次の結果が生成されます-
出力
hello.
Note− Stringクラスは不変であるため、一度作成するとStringオブジェクトを変更できません。文字列に多くの変更を加える必要がある場合は、StringBufferクラスとStringBuilderクラスを使用する必要があります。
文字列の長さ
オブジェクトに関する情報を取得するために使用されるメソッドは、 accessor methods。文字列で使用できるアクセサメソッドの1つは、文字列オブジェクトに含まれる文字数を返すlength()メソッドです。
次のプログラムはの例です length()、メソッド文字列クラス。
例
public class StringDemo {
public static void main(String args[]) {
String palindrome = "Dot saw I was Tod";
int len = palindrome.length();
System.out.println( "String Length is : " + len );
}
}
これにより、次の結果が生成されます-
出力
String Length is : 17
文字列の連結
Stringクラスには、2つの文字列を連結するためのメソッドが含まれています-
string1.concat(string2);
これは、最後にstring2が追加されたstring1である新しい文字列を返します。−のように、文字列リテラルでconcat()メソッドを使用することもできます。
"My name is ".concat("Zara");
文字列は、-のように、より一般的に+演算子で連結されます。
"Hello," + " world" + "!"
その結果、-
"Hello, world!"
次の例を見てみましょう-
例
public class StringDemo {
public static void main(String args[]) {
String string1 = "saw I was ";
System.out.println("Dot " + string1 + "Tod");
}
}
これにより、次の結果が生成されます-
出力
Dot saw I was Tod
フォーマット文字列の作成
フォーマットされた数値で出力を出力するためのprintf()メソッドとformat()メソッドがあります。Stringクラスには、PrintStreamオブジェクトではなくStringオブジェクトを返す同等のクラスメソッドformat()があります。
Stringの静的format()メソッドを使用すると、1回限りの印刷ステートメントではなく、再利用できるフォーマット済みの文字列を作成できます。たとえば、-の代わりに
例
System.out.printf("The value of the float variable is " +
"%f, while the value of the integer " +
"variable is %d, and the string " +
"is %s", floatVar, intVar, stringVar);
あなたは書くことができます-
String fs;
fs = String.format("The value of the float variable is " +
"%f, while the value of the integer " +
"variable is %d, and the string " +
"is %s", floatVar, intVar, stringVar);
System.out.println(fs);
文字列メソッド
Stringクラスでサポートされているメソッドのリストは次のとおりです-
シニア番号 | 方法と説明 |
---|---|
1 | char charAt(int index) 指定されたインデックスの文字を返します。 |
2 | int compareTo(Object o) この文字列を別のオブジェクトと比較します。 |
3 | int compareTo(String anotherString) 2つの文字列を辞書式に比較します。 |
4 | int compareToIgnoreCase(String str) 大文字と小文字の違いを無視して、2つの文字列を辞書式に比較します。 |
5 | 文字列concat(文字列str) 指定された文字列をこの文字列の末尾に連結します。 |
6 | ブール値contentEquals(StringBuffer sb) この文字列が指定されたStringBufferと同じ文字シーケンスを表す場合にのみ、trueを返します。 |
7 | 静的文字列copyValueOf(char [] data) 指定された配列の文字シーケンスを表す文字列を返します。 |
8 | static String copyValueOf(char [] data、int offset、int count) 指定された配列の文字シーケンスを表す文字列を返します。 |
9 | ブール値endsWith(文字列サフィックス) この文字列が指定されたサフィックスで終わるかどうかをテストします。 |
10 | boolean equals(Object anObject) この文字列を指定されたオブジェクトと比較します。 |
11 | boolean equalsIgnoreCase(String anotherString) 大文字と小文字の考慮を無視して、この文字列を別の文字列と比較します。 |
12 | バイトgetBytes() プラットフォームのデフォルトの文字セットを使用して、この文字列を一連のバイトにエンコードし、結果を新しいバイト配列に格納します。 |
13 | byte [] getBytes(String charsetName) 名前付き文字セットを使用してこの文字列をバイトシーケンスにエンコードし、結果を新しいバイト配列に格納します。 |
14 | void getChars(int srcBegin、int srcEnd、char [] dst、int dstBegin) この文字列から宛先文字配列に文字をコピーします。 |
15 | int hashCode() この文字列のハッシュコードを返します。 |
16 | int indexOf(int ch) 指定された文字が最初に出現するこの文字列内のインデックスを返します。 |
17 | int indexOf(int ch、int fromIndex) 指定された文字が最初に出現するこの文字列内のインデックスを返し、指定されたインデックスから検索を開始します。 |
18 | int indexOf(String str) 指定された部分文字列が最初に出現するこの文字列内のインデックスを返します。 |
19 | int indexOf(String str、int fromIndex) 指定されたインデックスから開始して、指定された部分文字列が最初に出現するこの文字列内のインデックスを返します。 |
20 | 文字列intern() 文字列オブジェクトの正規表現を返します。 |
21 | int lastIndexOf(int ch) 指定された文字が最後に出現するこの文字列内のインデックスを返します。 |
22 | int lastIndexOf(int ch、int fromIndex) 指定された文字の最後の出現のこの文字列内のインデックスを返し、指定されたインデックスから逆方向に検索します。 |
23 | int lastIndexOf(String str) 指定された部分文字列の右端にあるこの文字列内のインデックスを返します。 |
24 | int lastIndexOf(String str、int fromIndex) 指定された部分文字列の最後の出現のこの文字列内のインデックスを返し、指定されたインデックスから逆方向に検索します。 |
25 | int length() この文字列の長さを返します。 |
26 | ブール値の一致(文字列正規表現) この文字列が指定された正規表現に一致するかどうかを示します。 |
27 | boolean regionMatches(boolean ignoreCase、int toffset、String other、int ooffset、int len) 2つの文字列領域が等しいかどうかをテストします。 |
28 | boolean regionMatches(int toffset、String other、int ooffset、int len) 2つの文字列領域が等しいかどうかをテストします。 |
29 | 文字列replace(char oldChar、char newChar) この文字列内で出現するすべてのoldCharをnewCharに置き換えた結果の新しい文字列を返します。 |
30 | 文字列replaceAll(文字列正規表現、文字列置換 指定された正規表現に一致するこの文字列の各部分文字列を、指定された置換で置き換えます。 |
31 | 文字列replaceFirst(文字列正規表現、文字列置換) 指定された正規表現に一致するこの文字列の最初の部分文字列を、指定された置換で置き換えます。 |
32 | String [] split(String regex) 指定された正規表現の一致を中心にこの文字列を分割します。 |
33 | String [] split(String regex、int limit) 指定された正規表現の一致を中心にこの文字列を分割します。 |
34 | ブールstartsWith(文字列プレフィックス) この文字列が指定されたプレフィックスで始まるかどうかをテストします。 |
35 | ブールstartsWith(String prefix、int toffset) この文字列が、指定されたインデックスで始まる指定されたプレフィックスで始まるかどうかをテストします。 |
36 | CharSequence subSequence(int beginIndex、int endIndex) このシーケンスのサブシーケンスである新しい文字シーケンスを返します。 |
37 | 文字列部分文字列(intbeginIndex) この文字列の部分文字列である新しい文字列を返します。 |
38 | 文字列部分文字列(int beginIndex、int endIndex) この文字列の部分文字列である新しい文字列を返します。 |
39 | char [] toCharArray() この文字列を新しい文字配列に変換します。 |
40 | 文字列toLowerCase() デフォルトのロケールの規則を使用して、この文字列内のすべての文字を小文字に変換します。 |
41 | 文字列toLowerCase(ロケールロケール) 指定されたロケールのルールを使用して、この文字列内のすべての文字を小文字に変換します。 |
42 | 文字列toString() このオブジェクト(すでに文字列です!)自体が返されます。 |
43 | 文字列toUpperCase() デフォルトのロケールの規則を使用して、この文字列内のすべての文字を大文字に変換します。 |
44 | 文字列toUpperCase(ロケールロケール) 指定されたロケールのルールを使用して、この文字列内のすべての文字を大文字に変換します。 |
45 | 文字列trim() 前後の空白を省略して、文字列のコピーを返します。 |
46 | static String valueOf(プリミティブデータ型x) 渡されたデータ型引数の文字列表現を返します。 |
Javaはデータ構造を提供します。 array、同じタイプの要素の固定サイズの順次コレクションを格納します。配列はデータのコレクションを格納するために使用されますが、配列を同じタイプの変数のコレクションと考える方が便利な場合がよくあります。
number0、number1、...、number99などの個々の変数を宣言する代わりに、numbersなどの1つの配列変数を宣言し、numbers [0]、numbers [1]、...、numbers [99]を使用して表現します。個々の変数。
このチュートリアルでは、インデックス付き変数を使用して、配列変数を宣言し、配列を作成し、配列を処理する方法を紹介します。
配列変数の宣言
プログラムで配列を使用するには、配列を参照する変数を宣言し、変数が参照できる配列のタイプを指定する必要があります。配列変数を宣言するための構文は次のとおりです-
構文
dataType[] arrayRefVar; // preferred way.
or
dataType arrayRefVar[]; // works but not preferred way.
Note −スタイル dataType[] arrayRefVarが好ましい。スタイルdataType arrayRefVar[] C / C ++言語に由来し、C / C ++プログラマーに対応するためにJavaで採用されました。
例
次のコードスニペットは、この構文の例です-
double[] myList; // preferred way.
or
double myList[]; // works but not preferred way.
配列の作成
次の構文でnew演算子を使用して、配列を作成できます。
構文
arrayRefVar = new dataType[arraySize];
上記のステートメントは2つのことを行います-
新しいdataType [arraySize]を使用して配列を作成します。
新しく作成された配列の参照を変数arrayRefVarに割り当てます。
以下に示すように、配列変数の宣言、配列の作成、および配列の参照の変数への割り当てを1つのステートメントに組み合わせることができます。
dataType[] arrayRefVar = new dataType[arraySize];
または、次のように配列を作成することもできます-
dataType[] arrayRefVar = {value0, value1, ..., valuek};
配列要素には、 index。配列インデックスは0ベースです。つまり、0から始まりますarrayRefVar.length-1。
例
次のステートメントは、配列変数myListを宣言し、double型の10個の要素の配列を作成し、その参照をmyList −に割り当てます。
double[] myList = new double[10];
次の図は、配列myListを表しています。ここで、myListは10個のdouble値を保持し、インデックスは0から9です。
配列の処理
配列要素を処理するとき、私たちはしばしばどちらかを使用します for ループまたは foreach 配列内のすべての要素が同じタイプであり、配列のサイズがわかっているため、ループします。
例
これは、配列を作成、初期化、および処理する方法を示す完全な例です-
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// Print all the array elements
for (int i = 0; i < myList.length; i++) {
System.out.println(myList[i] + " ");
}
// Summing all elements
double total = 0;
for (int i = 0; i < myList.length; i++) {
total += myList[i];
}
System.out.println("Total is " + total);
// Finding the largest element
double max = myList[0];
for (int i = 1; i < myList.length; i++) {
if (myList[i] > max) max = myList[i];
}
System.out.println("Max is " + max);
}
}
これにより、次の結果が生成されます-
出力
1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5
foreachループ
JDK 1.5では、foreachループまたは拡張forループと呼ばれる新しいforループが導入されました。これにより、インデックス変数を使用せずに配列全体を順番にトラバースできます。
例
次のコードは、配列myList −のすべての要素を表示します。
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// Print all the array elements
for (double element: myList) {
System.out.println(element);
}
}
}
これにより、次の結果が生成されます-
出力
1.9
2.9
3.4
3.5
メソッドへの配列の受け渡し
プリミティブ型の値をメソッドに渡すことができるのと同じように、配列をメソッドに渡すこともできます。たとえば、次のメソッドは、int 配列-
例
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
配列を渡すことで呼び出すことができます。たとえば、次のステートメントはprintArrayメソッドを呼び出して、3、1、2、6、4、および2 −を表示します。
例
printArray(new int[]{3, 1, 2, 6, 4, 2});
メソッドから配列を返す
メソッドが配列を返すこともあります。たとえば、次のメソッドは、別の配列の反転である配列を返します-
例
public static int[] reverse(int[] list) {
int[] result = new int[list.length];
for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
result[j] = list[i];
}
return result;
}
配列クラス
java.util.Arraysクラスには、配列の並べ替えと検索、配列の比較、配列要素の入力のためのさまざまな静的メソッドが含まれています。これらのメソッドは、すべてのプリミティブ型に対してオーバーロードされます。
シニア番号 | 方法と説明 |
---|---|
1 | public static int binarySearch(Object[] a, Object key) バイナリ検索アルゴリズムを使用して、指定されたオブジェクトの配列(Byte、Int、doubleなど)で指定された値を検索します。この呼び出しを行う前に、配列をソートする必要があります。リストに含まれている場合、これは検索キーのインデックスを返します。それ以外の場合は、(–(挿入ポイント+ 1))を返します。 |
2 | public static boolean equals(long[] a, long[] a2) 指定されたlongの2つの配列が互いに等しい場合、trueを返します。両方の配列に同じ数の要素が含まれ、2つの配列の対応する要素のペアがすべて等しい場合、2つの配列は等しいと見なされます。これは、2つの配列が等しい場合にtrueを返します。同じメソッドを他のすべてのプリミティブデータ型(Byte、short、Intなど)で使用できます。 |
3 | public static void fill(int[] a, int val) 指定されたint配列の各要素に指定されたint値を割り当てます。同じメソッドを他のすべてのプリミティブデータ型(Byte、short、Intなど)で使用できます。 |
4 | public static void sort(Object[] a) 指定されたオブジェクトの配列を、その要素の自然な順序に従って昇順で並べ替えます。同じメソッドを他のすべてのプリミティブデータ型(Byte、short、Intなど)で使用できます。 |
Javaは Date で利用可能なクラス java.util パッケージの場合、このクラスは現在の日付と時刻をカプセル化します。
次の表に示すように、Dateクラスは2つのコンストラクターをサポートします。
シニア番号 | コンストラクターと説明 |
---|---|
1 | Date( ) このコンストラクターは、オブジェクトを現在の日付と時刻で初期化します。 |
2 | Date(long millisec) このコンストラクターは、1970年1月1日の午前0時から経過したミリ秒数に等しい引数を受け入れます。 |
以下は、日付クラスのメソッドです。
シニア番号 | 方法と説明 |
---|---|
1 | boolean after(Date date) 呼び出し元のDateオブジェクトにdateで指定された日付より後の日付が含まれている場合はtrueを返し、そうでない場合はfalseを返します。 |
2 | boolean before(Date date) 呼び出し元のDateオブジェクトにdateで指定された日付より前の日付が含まれている場合はtrueを返し、そうでない場合はfalseを返します。 |
3 | Object clone( ) 呼び出し元のDateオブジェクトを複製します。 |
4 | int compareTo(Date date) 呼び出し元のオブジェクトの値を日付の値と比較します。値が等しい場合は0を返します。呼び出し元のオブジェクトが日付より前の場合は、負の値を返します。呼び出し元のオブジェクトが日付より後の場合は、正の値を返します。 |
5 | int compareTo(Object obj) objがDateクラスの場合、compareTo(Date)と同じように動作します。それ以外の場合は、ClassCastExceptionをスローします。 |
6 | boolean equals(Object date) 呼び出し元のDateオブジェクトにdateで指定されたものと同じ時刻と日付が含まれている場合はtrueを返し、そうでない場合はfalseを返します。 |
7 | long getTime( ) 1970年1月1日から経過したミリ秒数を返します。 |
8 | int hashCode( ) 呼び出し元オブジェクトのハッシュコードを返します。 |
9 | void setTime(long time) 1970年1月1日午前0時からの経過時間をミリ秒単位で表すtimeで指定された時刻と日付を設定します。 |
10 | String toString( ) 呼び出し元のDateオブジェクトを文字列に変換し、結果を返します。 |
現在の日付と時刻を取得する
これは、Javaで現在の日付と時刻を取得するための非常に簡単な方法です。toString()メソッドで単純なDateオブジェクトを使用して、次のように現在の日付と時刻を出力できます。
例
import java.util.Date;
public class DateDemo {
public static void main(String args[]) {
// Instantiate a Date object
Date date = new Date();
// display time and date using toString()
System.out.println(date.toString());
}
}
これにより、次の結果が生成されます-
出力
on May 04 09:51:52 CDT 2009
日付の比較
以下は、2つの日付を比較する3つの方法です-
getTime()を使用して、両方のオブジェクトについて1970年1月1日の午前0時から経過したミリ秒数を取得し、これら2つの値を比較できます。
メソッドbefore()、after()、equals()を使用できます。たとえば、月の12日は18日の前に来るため、new Date(99、2、12).before(new Date(99、2、18))はtrueを返します。
Comparableインターフェースによって定義され、Dateによって実装されるcompareTo()メソッドを使用できます。
SimpleDateFormatを使用した日付の書式設定
SimpleDateFormatは、ロケールに依存する方法で日付をフォーマットおよび解析するための具象クラスです。SimpleDateFormatを使用すると、日時フォーマット用のユーザー定義パターンを選択することから始めることができます。
例
import java.util.*;
import java.text.*;
public class DateDemo {
public static void main(String args[]) {
Date dNow = new Date( );
SimpleDateFormat ft =
new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
System.out.println("Current Date: " + ft.format(dNow));
}
}
これにより、次の結果が生成されます-
出力
Current Date: Sun 2004.07.18 at 04:14:09 PM PDT
単純なDateFormatフォーマットコード
時間形式を指定するには、時間パターン文字列を使用します。このパターンでは、すべてのASCII文字がパターン文字として予約されており、次のように定義されています。
キャラクター | 説明 | 例 |
---|---|---|
G | 時代指定子 | 広告 |
y | 4桁の年 | 2001年 |
M | 年の月 | 7月または07 |
d | 月の日 | 10 |
h | 午前/午後の時間(1〜12) | 12 |
H | 1日の時間(0〜23) | 22 |
m | 時間単位の分 | 30 |
s | 分で2番目 | 55 |
S | ミリ秒 | 234 |
E | 曜日 | 火曜日 |
D | 年間の日 | 360 |
F | 月の曜日 | 2(7月第2水曜日) |
w | 年間の週 | 40 |
W | 月の週 | 1 |
a | AM / PMマーカー | 午後 |
k | 1日の時間(1〜24) | 24 |
K | 午前/午後の時間(0〜11) | 10 |
z | タイムゾーン | 東部標準時 |
' | テキストのエスケープ | デリミタ |
「」 | 一重引用符 | ` |
printfを使用した日付のフォーマット
日付と時刻のフォーマットは、を使用して非常に簡単に行うことができます printf方法。で始まる2文字の形式を使用しますt 次のコードに示すように、表の文字の1つで終わります。
例
import java.util.Date;
public class DateDemo {
public static void main(String args[]) {
// Instantiate a Date object
Date date = new Date();
// display time and date
String str = String.format("Current Date/Time : %tc", date );
System.out.printf(str);
}
}
これにより、次の結果が生成されます-
出力
Current Date/Time : Sat Dec 15 16:37:57 MST 2012
各部分をフォーマットするために日付を複数回指定する必要がある場合は、少しばかげています。そのため、フォーマット文字列は、フォーマットする引数のインデックスを示すことができます。
インデックスは%の直後に続く必要があり、$で終了する必要があります。
例
import java.util.Date;
public class DateDemo {
public static void main(String args[]) {
// Instantiate a Date object
Date date = new Date();
// display time and date
System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date);
}
}
これにより、次の結果が生成されます-
出力
Due date: February 09, 2004
または、<フラグを使用することもできます。これは、前のフォーマット仕様と同じ引数を再度使用する必要があることを示しています。
例
import java.util.Date;
public class DateDemo {
public static void main(String args[]) {
// Instantiate a Date object
Date date = new Date();
// display formatted date
System.out.printf("%s %tB %<te, %<tY", "Due date:", date);
}
}
これにより、次の結果が生成されます-
出力
Due date: February 09, 2004
日付と時刻の変換文字
キャラクター | 説明 | 例 |
---|---|---|
c | 完全な日付と時刻 | 月5月4日09:51:52CDT 2009 |
F | ISO8601日付 | 2004-02-09 |
D | 米国でフォーマットされた日付(月/日/年) | 2004年2月9日 |
T | 24時間 | 18:05:19 |
r | 12時間 | 06:05:19 pm |
R | 24時間制、秒なし | 18:05 |
Y | 4桁の年(先行ゼロ付き) | 2004年 |
y | 年の最後の2桁(先行ゼロ付き) | 0404 |
C | 年の最初の2桁(先行ゼロ付き) | 20 |
B | 完全な月の名前 | 2月 |
b | 略称月名 | 2月 |
m | 2桁の月(先行ゼロ付き) | 02 |
d | 2桁の日(先行ゼロ付き) | 03 |
e | 2桁の日(先行ゼロなし) | 9 |
A | 完全な平日の名前 | 月曜 |
a | 平日の略称 | 月曜日 |
j | 3桁の曜日(先行ゼロ付き) | 069 |
H | 00から23までの2桁の時間(先行ゼロ付き) | 18 |
k | 0から23までの2桁の時間(先行ゼロなし) | 18 |
私 | 01から12までの2桁の時間(先行ゼロ付き) | 06 |
l | 1〜12の2桁の時間(先行ゼロなし) | 6 |
M | 2桁の分(先行ゼロ付き) | 05 |
S | 2桁の秒(先行ゼロ付き) | 19 |
L | 3桁のミリ秒(先行ゼロ付き) | 047 |
N | 9桁のナノ秒(先行ゼロ付き) | 047000000 |
P | 大文字の朝または午後のマーカー | 午後 |
p | 小文字の朝または午後のマーカー | 午後 |
z | GMTからのRFC822数値オフセット | -0800 |
Z | タイムゾーン | PST |
s | 1970-01-01 00:00:00GMTからの秒数 | 1078884319 |
Q | 1970-01-01 00:00:00GMTからのミリ秒 | 1078884319047 |
日付と時刻に関連する他の便利なクラスがあります。詳細については、Java標準のドキュメントを参照してください。
文字列を日付に解析する
SimpleDateFormatクラスには、いくつかの追加メソッド、特にparse()があります。これは、指定されたSimpleDateFormatオブジェクトに格納されている形式に従って文字列を解析しようとします。
例
import java.util.*;
import java.text.*;
public class DateDemo {
public static void main(String args[]) {
SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");
String input = args.length == 0 ? "1818-11-11" : args[0];
System.out.print(input + " Parses as ");
Date t;
try {
t = ft.parse(input);
System.out.println(t);
} catch (ParseException e) {
System.out.println("Unparseable using " + ft);
}
}
}
上記のプログラムを実行すると、次の結果が得られます。
出力
1818-11-11 Parses as Wed Nov 11 00:00:00 EST 1818
しばらく眠る
1ミリ秒からコンピュータの寿命までの任意の期間スリープできます。たとえば、次のプログラムは3秒間スリープします-
例
import java.util.*;
public class SleepDemo {
public static void main(String args[]) {
try {
System.out.println(new Date( ) + "\n");
Thread.sleep(5*60*10);
System.out.println(new Date( ) + "\n");
} catch (Exception e) {
System.out.println("Got an exception!");
}
}
}
これにより、次の結果が生成されます-
出力
Sun May 03 18:04:41 GMT 2009
Sun May 03 18:04:51 GMT 2009
経過時間の測定
場合によっては、ミリ秒単位で特定の時点を測定する必要があります。それでは、上記の例をもう一度書き直してみましょう-
例
import java.util.*;
public class DiffDemo {
public static void main(String args[]) {
try {
long start = System.currentTimeMillis( );
System.out.println(new Date( ) + "\n");
Thread.sleep(5*60*10);
System.out.println(new Date( ) + "\n");
long end = System.currentTimeMillis( );
long diff = end - start;
System.out.println("Difference is : " + diff);
} catch (Exception e) {
System.out.println("Got an exception!");
}
}
}
これにより、次の結果が生成されます-
出力
Sun May 03 18:16:51 GMT 2009
Sun May 03 18:16:57 GMT 2009
Difference is : 5993
グレゴリアンカレンダークラス
GregorianCalendarは、使い慣れた通常のグレゴリオ暦を実装するCalendarクラスの具体的な実装です。このチュートリアルではCalendarクラスについては説明しませんでした。これについては、標準のJavaドキュメントを調べることができます。
ザ・ getInstance( )Calendarのメソッドは、デフォルトのロケールとタイムゾーンの現在の日付と時刻で初期化されたGregorianCalendarを返します。GregorianCalendarは、ADとBCの2つのフィールドを定義します。これらは、グレゴリオ暦で定義された2つの時代を表しています。
GregorianCalendarオブジェクトのコンストラクターもいくつかあります-
シニア番号 | コンストラクターと説明 |
---|---|
1 | GregorianCalendar() デフォルトのロケールでデフォルトのタイムゾーンの現在の時刻を使用して、デフォルトのGregorianCalendarを構築します。 |
2 | GregorianCalendar(int year, int month, int date) 指定された日付をデフォルトのロケールでデフォルトのタイムゾーンに設定して、GregorianCalendarを構築します。 |
3 | GregorianCalendar(int year, int month, int date, int hour, int minute) 指定された日付と時刻がデフォルトのロケールでデフォルトのタイムゾーンに設定されたGregorianCalendarを構築します。 |
4 | GregorianCalendar(int year, int month, int date, int hour, int minute, int second) 指定された日付と時刻がデフォルトのロケールでデフォルトのタイムゾーンに設定されたGregorianCalendarを構築します。 |
5 | GregorianCalendar(Locale aLocale) 指定されたロケールのデフォルトのタイムゾーンの現在の時刻に基づいてGregorianCalendarを構築します。 |
6 | GregorianCalendar(TimeZone zone) デフォルトのロケールで、指定されたタイムゾーンの現在の時刻に基づいてGregorianCalendarを構築します。 |
7 | GregorianCalendar(TimeZone zone, Locale aLocale) 指定されたロケールの指定されたタイムゾーンの現在の時刻に基づいてGregorianCalendarを構築します。 |
これは、GregorianCalendarクラスによって提供されるいくつかの便利なサポートメソッドのリストです-
シニア番号 | 方法と説明 |
---|---|
1 | void add(int field, int amount) カレンダーのルールに基づいて、指定された(署名された)時間を指定された時間フィールドに追加します。 |
2 | protected void computeFields() UTCをミリ秒単位で時間フィールド値に変換します。 |
3 | protected void computeTime() カレンダーを上書きする時間フィールドの値をミリ秒単位のUTCに変換します。 |
4 | boolean equals(Object obj) このGregorianCalendarをオブジェクト参照と比較します。 |
5 | int get(int field) 指定された時間フィールドの値を取得します。 |
6 | int getActualMaximum(int field) 現在の日付を指定して、このフィールドが持つことができる最大値を返します。 |
7 | int getActualMinimum(int field) 現在の日付を指定して、このフィールドが持つことができる最小値を返します。 |
8 | int getGreatestMinimum(int field) 変化する場合、指定されたフィールドの最大最小値を返します。 |
9 | Date getGregorianChange() グレゴリオ暦の変更日を取得します。 |
10 | int getLeastMaximum(int field) 変化する場合、指定されたフィールドの最小最大値を返します。 |
11 | int getMaximum(int field) 指定されたフィールドの最大値を返します。 |
12 | Date getTime() このカレンダーの現在の時刻を取得します。 |
13 | long getTimeInMillis() このカレンダーの現在の時刻をlongとして取得します。 |
14 | TimeZone getTimeZone() タイムゾーンを取得します。 |
15 | int getMinimum(int field) 指定されたフィールドの最小値を返します。 |
16 | int hashCode() hashCodeをオーバーライドします。 |
17 | boolean isLeapYear(int year) 指定された年がうるう年であるかどうかを判別します。 |
18 | void roll(int field, boolean up) 大きなフィールドを変更せずに、指定された時間フィールドで1単位の時間を加算または減算(上/下)します。 |
19 | void set(int field, int value) 指定された値で時間フィールドを設定します。 |
20 | void set(int year, int month, int date) フィールドyear、month、およびdateの値を設定します。 |
21 | void set(int year, int month, int date, int hour, int minute) フィールドyear、month、date、hour、およびminuteの値を設定します。 |
22 | void set(int year, int month, int date, int hour, int minute, int second) フィールドyear、month、date、hour、minute、およびsecondの値を設定します。 |
23 | void setGregorianChange(Date date) GregorianCalendarの変更日を設定します。 |
24 | void setTime(Date date) このカレンダーの現在の時刻を指定された日付で設定します。 |
25 | void setTimeInMillis(long millis) 指定されたlong値からこのカレンダーの現在の時刻を設定します。 |
26 | void setTimeZone(TimeZone value) 指定されたタイムゾーン値でタイムゾーンを設定します。 |
27 | String toString() このカレンダーの文字列表現を返します。 |
例
import java.util.*;
public class GregorianCalendarDemo {
public static void main(String args[]) {
String months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
"Oct", "Nov", "Dec"};
int year;
// Create a Gregorian calendar initialized
// with the current date and time in the
// default locale and timezone.
GregorianCalendar gcalendar = new GregorianCalendar();
// Display current time and date information.
System.out.print("Date: ");
System.out.print(months[gcalendar.get(Calendar.MONTH)]);
System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
System.out.println(year = gcalendar.get(Calendar.YEAR));
System.out.print("Time: ");
System.out.print(gcalendar.get(Calendar.HOUR) + ":");
System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
System.out.println(gcalendar.get(Calendar.SECOND));
// Test if the current year is a leap year
if(gcalendar.isLeapYear(year)) {
System.out.println("The current year is a leap year");
}else {
System.out.println("The current year is not a leap year");
}
}
}
これにより、次の結果が生成されます-
出力
Date: Apr 22 2009
Time: 11:25:27
The current year is not a leap year
Calendarクラスで使用可能な定数の完全なリストについては、標準のJavaドキュメントを参照してください。
Javaは、正規表現とのパターンマッチング用のjava.util.regexパッケージを提供します。Javaの正規表現は、Perlプログラミング言語と非常によく似ており、習得が非常に簡単です。
正規表現は、パターンに保持された特殊な構文を使用して、他の文字列または文字列のセットを照合または検索するのに役立つ特殊な文字シーケンスです。これらは、テキストやデータを検索、編集、または操作するために使用できます。
java.util.regexパッケージは、主に次の3つのクラスで構成されています-
Pattern Class−パターンオブジェクトは、正規表現をコンパイルした表現です。Patternクラスは、パブリックコンストラクターを提供しません。パターンを作成するには、最初にそのパブリックスタティックの1つを呼び出す必要がありますcompile()その後、Patternオブジェクトを返すメソッド。これらのメソッドは、最初の引数として正規表現を受け入れます。
Matcher Class− Matcherオブジェクトは、パターンを解釈し、入力文字列に対して一致操作を実行するエンジンです。Patternクラスと同様に、Matcherはパブリックコンストラクターを定義しません。を呼び出すことにより、Matcherオブジェクトを取得しますmatcher() Patternオブジェクトのメソッド。
PatternSyntaxException − PatternSyntaxExceptionオブジェクトは、正規表現パターンの構文エラーを示すチェックされていない例外です。
グループのキャプチャ
グループのキャプチャは、複数の文字を1つのユニットとして扱う方法です。これらは、グループ化する文字を括弧のセット内に配置することによって作成されます。たとえば、正規表現(dog)は、文字「d」、「o」、および「g」を含む単一のグループを作成します。
キャプチャグループは、左から右に開いた括弧を数えることによって番号が付けられます。たとえば、式((A)(B(C)))には、このようなグループが4つあります。
- ((A)(B(C)))
- (A)
- (B(C))
- (C)
式に存在するグループの数を確認するには、マッチャーオブジェクトでgroupCountメソッドを呼び出します。groupCountメソッドはint マッチャーのパターンに存在するキャプチャグループの数を示します。
常に式全体を表す特別なグループ、グループ0もあります。このグループは、groupCountによって報告される合計には含まれません。
Example
次の例は、指定された英数字の文字列から数字列を見つける方法を示しています。
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
public static void main( String args[] ) {
// String to be scanned to find the pattern.
String line = "This order was placed for QT3000! OK?";
String pattern = "(.*)(\\d+)(.*)";
// Create a Pattern object
Pattern r = Pattern.compile(pattern);
// Now create matcher object.
Matcher m = r.matcher(line);
if (m.find( )) {
System.out.println("Found value: " + m.group(0) );
System.out.println("Found value: " + m.group(1) );
System.out.println("Found value: " + m.group(2) );
}else {
System.out.println("NO MATCH");
}
}
}
これにより、次の結果が生成されます-
Output
Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0
正規表現の構文
これは、Javaで使用可能なすべての正規表現メタ文字構文をリストした表です。
部分式 | マッチス |
---|---|
^ | 行の先頭に一致します。 |
$ | 行の終わりに一致します。 |
。 | 改行以外の任意の1文字に一致します。使用するm オプションを使用すると、改行にも一致させることができます。 |
[...] | 角かっこ内の任意の1文字に一致します。 |
[^...] | Matches any single character not in brackets. |
\A | Beginning of the entire string. |
\z | End of the entire string. |
\Z | End of the entire string except allowable final line terminator. |
re* | Matches 0 or more occurrences of the preceding expression. |
re+ | Matches 1 or more of the previous thing. |
re? | Matches 0 or 1 occurrence of the preceding expression. |
re{ n} | Matches exactly n number of occurrences of the preceding expression. |
re{ n,} | Matches n or more occurrences of the preceding expression. |
re{ n, m} | Matches at least n and at most m occurrences of the preceding expression. |
a| b | Matches either a or b. |
(re) | Groups regular expressions and remembers the matched text. |
(?: re) | Groups regular expressions without remembering the matched text. |
(?> re) | Matches the independent pattern without backtracking. |
\w | Matches the word characters. |
\W | Matches the nonword characters. |
\s | Matches the whitespace. Equivalent to [\t\n\r\f]. |
\S | Matches the nonwhitespace. |
\d | Matches the digits. Equivalent to [0-9]. |
\D | Matches the nondigits. |
\A | Matches the beginning of the string. |
\Z | Matches the end of the string. If a newline exists, it matches just before newline. |
\z | Matches the end of the string. |
\G | Matches the point where the last match finished. |
\n | Back-reference to capture group number "n". |
\b | Matches the word boundaries when outside the brackets. Matches the backspace (0x08) when inside the brackets. |
\B | Matches the nonword boundaries. |
\n, \t, etc. | Matches newlines, carriage returns, tabs, etc. |
\Q | Escape (quote) all characters up to \E. |
\E | Ends quoting begun with \Q. |
Methods of the Matcher Class
Here is a list of useful instance methods −
Index Methods
Index methods provide useful index values that show precisely where the match was found in the input string −
Sr.No. | Method & Description |
---|---|
1 | public int start() Returns the start index of the previous match. |
2 | public int start(int group) Returns the start index of the subsequence captured by the given group during the previous match operation. |
3 | public int end() Returns the offset after the last character matched. |
4 | public int end(int group) Returns the offset after the last character of the subsequence captured by the given group during the previous match operation. |
Study Methods
Study methods review the input string and return a Boolean indicating whether or not the pattern is found −
Sr.No. | Method & Description |
---|---|
1 | public boolean lookingAt() Attempts to match the input sequence, starting at the beginning of the region, against the pattern. |
2 | public boolean find() Attempts to find the next subsequence of the input sequence that matches the pattern. |
3 | public boolean find(int start) Resets this matcher and then attempts to find the next subsequence of the input sequence that matches the pattern, starting at the specified index. |
4 | public boolean matches() Attempts to match the entire region against the pattern. |
Replacement Methods
Replacement methods are useful methods for replacing text in an input string −
Sr.No. | Method & Description |
---|---|
1 | public Matcher appendReplacement(StringBuffer sb, String replacement) Implements a non-terminal append-and-replace step. |
2 | public StringBuffer appendTail(StringBuffer sb) Implements a terminal append-and-replace step. |
3 | public String replaceAll(String replacement) Replaces every subsequence of the input sequence that matches the pattern with the given replacement string. |
4 | public String replaceFirst(String replacement) Replaces the first subsequence of the input sequence that matches the pattern with the given replacement string. |
5 | public static String quoteReplacement(String s) Returns a literal replacement String for the specified String. This method produces a String that will work as a literal replacement s in the appendReplacement method of the Matcher class. |
The start and end Methods
Following is the example that counts the number of times the word "cat" appears in the input string −
Example
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
private static final String REGEX = "\\bcat\\b";
private static final String INPUT = "cat cat cat cattie cat";
public static void main( String args[] ) {
Pattern p = Pattern.compile(REGEX);
Matcher m = p.matcher(INPUT); // get a matcher object
int count = 0;
while(m.find()) {
count++;
System.out.println("Match number "+count);
System.out.println("start(): "+m.start());
System.out.println("end(): "+m.end());
}
}
}
This will produce the following result −
Output
Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22
You can see that this example uses word boundaries to ensure that the letters "c" "a" "t" are not merely a substring in a longer word. It also gives some useful information about where in the input string the match has occurred.
The start method returns the start index of the subsequence captured by the given group during the previous match operation, and the end returns the index of the last character matched, plus one.
The matches and lookingAt Methods
The matches and lookingAt methods both attempt to match an input sequence against a pattern. The difference, however, is that matches requires the entire input sequence to be matched, while lookingAt does not.
Both methods always start at the beginning of the input string. Here is the example explaining the functionality −
Example
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
private static final String REGEX = "foo";
private static final String INPUT = "fooooooooooooooooo";
private static Pattern pattern;
private static Matcher matcher;
public static void main( String args[] ) {
pattern = Pattern.compile(REGEX);
matcher = pattern.matcher(INPUT);
System.out.println("Current REGEX is: "+REGEX);
System.out.println("Current INPUT is: "+INPUT);
System.out.println("lookingAt(): "+matcher.lookingAt());
System.out.println("matches(): "+matcher.matches());
}
}
This will produce the following result −
Output
Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false
The replaceFirst and replaceAll Methods
The replaceFirst and replaceAll methods replace the text that matches a given regular expression. As their names indicate, replaceFirst replaces the first occurrence, and replaceAll replaces all occurrences.
Here is the example explaining the functionality −
Example
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
private static String REGEX = "dog";
private static String INPUT = "The dog says meow. " + "All dogs say meow.";
private static String REPLACE = "cat";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// get a matcher object
Matcher m = p.matcher(INPUT);
INPUT = m.replaceAll(REPLACE);
System.out.println(INPUT);
}
}
This will produce the following result −
Output
The cat says meow. All cats say meow.
The appendReplacement and appendTail Methods
The Matcher class also provides appendReplacement and appendTail methods for text replacement.
Here is the example explaining the functionality −
Example
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
private static String REGEX = "a*b";
private static String INPUT = "aabfooaabfooabfoob";
private static String REPLACE = "-";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// get a matcher object
Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
while(m.find()) {
m.appendReplacement(sb, REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}
This will produce the following result −
Output
-foo-foo-foo-
PatternSyntaxException Class Methods
A PatternSyntaxException is an unchecked exception that indicates a syntax error in a regular expression pattern. The PatternSyntaxException class provides the following methods to help you determine what went wrong −
Sr.No. | Method & Description |
---|---|
1 | public String getDescription() Retrieves the description of the error. |
2 | public int getIndex() Retrieves the error index. |
3 | public String getPattern() Retrieves the erroneous regular expression pattern. |
4 | public String getMessage() Returns a multi-line string containing the description of the syntax error and its index, the erroneous regular expression pattern, and a visual indication of the error index within the pattern. |
A Java method is a collection of statements that are grouped together to perform an operation. When you call the System.out.println() method, for example, the system actually executes several statements in order to display a message on the console.
Now you will learn how to create your own methods with or without return values, invoke a method with or without parameters, and apply method abstraction in the program design.
Creating Method
Considering the following example to explain the syntax of a method −
Syntax
public static int methodName(int a, int b) {
// body
}
Here,
public static − modifier
int − return type
methodName − name of the method
a, b − formal parameters
int a, int b − list of parameters
Method definition consists of a method header and a method body. The same is shown in the following syntax −
Syntax
modifier returnType nameOfMethod (Parameter List) {
// method body
}
The syntax shown above includes −
modifier − It defines the access type of the method and it is optional to use.
returnType − Method may return a value.
nameOfMethod − This is the method name. The method signature consists of the method name and the parameter list.
Parameter List − The list of parameters, it is the type, order, and number of parameters of a method. These are optional, method may contain zero parameters.
method body − The method body defines what the method does with the statements.
Example
Here is the source code of the above defined method called min(). This method takes two parameters num1 and num2 and returns the maximum between the two −
/** the snippet returns the minimum between two numbers */
public static int minFunction(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}
Method Calling
For using a method, it should be called. There are two ways in which a method is called i.e., method returns a value or returning nothing (no return value).
The process of method calling is simple. When a program invokes a method, the program control gets transferred to the called method. This called method then returns control to the caller in two conditions, when −
- the return statement is executed.
- it reaches the method ending closing brace.
The methods returning void is considered as call to a statement. Lets consider an example −
System.out.println("This is tutorialspoint.com!");
The method returning value can be understood by the following example −
int result = sum(6, 9);
Following is the example to demonstrate how to define a method and how to call it −
Example
public class ExampleMinNumber {
public static void main(String[] args) {
int a = 11;
int b = 6;
int c = minFunction(a, b);
System.out.println("Minimum Value = " + c);
}
/** returns the minimum of two numbers */
public static int minFunction(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}
}
This will produce the following result −
Output
Minimum value = 6
The void Keyword
The void keyword allows us to create methods which do not return a value. Here, in the following example we're considering a void method methodRankPoints. This method is a void method, which does not return any value. Call to a void method must be a statement i.e. methodRankPoints(255.7);. It is a Java statement which ends with a semicolon as shown in the following example.
Example
public class ExampleVoid {
public static void main(String[] args) {
methodRankPoints(255.7);
}
public static void methodRankPoints(double points) {
if (points >= 202.5) {
System.out.println("Rank:A1");
}else if (points >= 122.4) {
System.out.println("Rank:A2");
}else {
System.out.println("Rank:A3");
}
}
}
This will produce the following result −
Output
Rank:A1
Passing Parameters by Value
While working under calling process, arguments is to be passed. These should be in the same order as their respective parameters in the method specification. Parameters can be passed by value or by reference.
Passing Parameters by Value means calling a method with a parameter. Through this, the argument value is passed to the parameter.
Example
The following program shows an example of passing parameter by value. The values of the arguments remains the same even after the method invocation.
public class swappingExample {
public static void main(String[] args) {
int a = 30;
int b = 45;
System.out.println("Before swapping, a = " + a + " and b = " + b);
// Invoke the swap method
swapFunction(a, b);
System.out.println("\n**Now, Before and After swapping values will be same here**:");
System.out.println("After swapping, a = " + a + " and b is " + b);
}
public static void swapFunction(int a, int b) {
System.out.println("Before swapping(Inside), a = " + a + " b = " + b);
// Swap n1 with n2
int c = a;
a = b;
b = c;
System.out.println("After swapping(Inside), a = " + a + " b = " + b);
}
}
This will produce the following result −
Output
Before swapping, a = 30 and b = 45
Before swapping(Inside), a = 30 b = 45
After swapping(Inside), a = 45 b = 30
**Now, Before and After swapping values will be same here**:
After swapping, a = 30 and b is 45
Method Overloading
When a class has two or more methods by the same name but different parameters, it is known as method overloading. It is different from overriding. In overriding, a method has the same method name, type, number of parameters, etc.
Let’s consider the example discussed earlier for finding minimum numbers of integer type. If, let’s say we want to find the minimum number of double type. Then the concept of overloading will be introduced to create two or more methods with the same name but different parameters.
The following example explains the same −
Example
public class ExampleOverloading {
public static void main(String[] args) {
int a = 11;
int b = 6;
double c = 7.3;
double d = 9.4;
int result1 = minFunction(a, b);
// same function name with different parameters
double result2 = minFunction(c, d);
System.out.println("Minimum Value = " + result1);
System.out.println("Minimum Value = " + result2);
}
// for integer
public static int minFunction(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}
// for double
public static double minFunction(double n1, double n2) {
double min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}
}
This will produce the following result −
Output
Minimum Value = 6
Minimum Value = 7.3
Overloading methods makes program readable. Here, two methods are given by the same name but with different parameters. The minimum number from integer and double types is the result.
Using Command-Line Arguments
Sometimes you will want to pass some information into a program when you run it. This is accomplished by passing command-line arguments to main( ).
A command-line argument is the information that directly follows the program's name on the command line when it is executed. To access the command-line arguments inside a Java program is quite easy. They are stored as strings in the String array passed to main( ).
Example
The following program displays all of the command-line arguments that it is called with −
public class CommandLine {
public static void main(String args[]) {
for(int i = 0; i<args.length; i++) {
System.out.println("args[" + i + "]: " + args[i]);
}
}
}
Try executing this program as shown here −
$java CommandLine this is a command line 200 -100
This will produce the following result −
Output
args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100
The this keyword
this is a keyword in Java which is used as a reference to the object of the current class, with in an instance method or a constructor. Using this you can refer the members of a class such as constructors, variables and methods.
Note − The keyword this is used only within instance methods or constructors
In general, the keyword this is used to −
Differentiate the instance variables from local variables if they have same names, within a constructor or a method.
class Student {
int age;
Student(int age) {
this.age = age;
}
}
Call one type of constructor (Parameterized constructor or default) from other in a class. It is known as explicit constructor invocation.
class Student {
int age
Student() {
this(20);
}
Student(int age) {
this.age = age;
}
}
Example
Here is an example that uses this keyword to access the members of a class. Copy and paste the following program in a file with the name, This_Example.java.
public class This_Example {
// Instance variable num
int num = 10;
This_Example() {
System.out.println("This is an example program on keyword this");
}
This_Example(int num) {
// Invoking the default constructor
this();
// Assigning the local variable num to the instance variable num
this.num = num;
}
public void greet() {
System.out.println("Hi Welcome to Tutorialspoint");
}
public void print() {
// Local variable num
int num = 20;
// Printing the local variable
System.out.println("value of local variable num is : "+num);
// Printing the instance variable
System.out.println("value of instance variable num is : "+this.num);
// Invoking the greet method of a class
this.greet();
}
public static void main(String[] args) {
// Instantiating the class
This_Example obj1 = new This_Example();
// Invoking the print method
obj1.print();
// Passing a new value to the num variable through Parameterized constructor
This_Example obj2 = new This_Example(30);
// Invoking the print method again
obj2.print();
}
}
This will produce the following result −
Output
This is an example program on keyword this
value of local variable num is : 20
value of instance variable num is : 10
Hi Welcome to Tutorialspoint
This is an example program on keyword this
value of local variable num is : 20
value of instance variable num is : 30
Hi Welcome to Tutorialspoint
Variable Arguments(var-args)
JDK 1.5 enables you to pass a variable number of arguments of the same type to a method. The parameter in the method is declared as follows −
typeName... parameterName
In the method declaration, you specify the type followed by an ellipsis (...). Only one variable-length parameter may be specified in a method, and this parameter must be the last parameter. Any regular parameters must precede it.
Example
public class VarargsDemo {
public static void main(String args[]) {
// Call method with variable args
printMax(34, 3, 3, 2, 56.5);
printMax(new double[]{1, 2, 3});
}
public static void printMax( double... numbers) {
if (numbers.length == 0) {
System.out.println("No argument passed");
return;
}
double result = numbers[0];
for (int i = 1; i < numbers.length; i++)
if (numbers[i] > result)
result = numbers[i];
System.out.println("The max value is " + result);
}
}
This will produce the following result −
Output
The max value is 56.5
The max value is 3.0
The finalize( ) Method
It is possible to define a method that will be called just before an object's final destruction by the garbage collector. This method is called finalize( ), and it can be used to ensure that an object terminates cleanly.
For example, you might use finalize( ) to make sure that an open file owned by that object is closed.
To add a finalizer to a class, you simply define the finalize( ) method. The Java runtime calls that method whenever it is about to recycle an object of that class.
Inside the finalize( ) method, you will specify those actions that must be performed before an object is destroyed.
The finalize( ) method has this general form −
protected void finalize( ) {
// finalization code here
}
Here, the keyword protected is a specifier that prevents access to finalize( ) by code defined outside its class.
This means that you cannot know when or even if finalize( ) will be executed. For example, if your program ends before garbage collection occurs, finalize( ) will not execute.
The java.io package contains nearly every class you might ever need to perform input and output (I/O) in Java. All these streams represent an input source and an output destination. The stream in the java.io package supports many data such as primitives, object, localized characters, etc.
Stream
A stream can be defined as a sequence of data. There are two kinds of Streams −
InPutStream − The InputStream is used to read data from a source.
OutPutStream − The OutputStream is used for writing data to a destination.
Java provides strong but flexible support for I/O related to files and networks but this tutorial covers very basic functionality related to streams and I/O. We will see the most commonly used examples one by one −
Byte Streams
Java byte streams are used to perform input and output of 8-bit bytes. Though there are many classes related to byte streams but the most frequently used classes are, FileInputStream and FileOutputStream. Following is an example which makes use of these two classes to copy an input file into an output file −
Example
import java.io.*;
public class CopyFile {
public static void main(String args[]) throws IOException {
FileInputStream in = null;
FileOutputStream out = null;
try {
in = new FileInputStream("input.txt");
out = new FileOutputStream("output.txt");
int c;
while ((c = in.read()) != -1) {
out.write(c);
}
}finally {
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}
}
}
それではファイルを作成しましょう input.txt 次の内容で-
This is test for copy file.
次のステップとして、上記のプログラムをコンパイルして実行します。これにより、input.txtと同じ内容のoutput.txtファイルが作成されます。それでは、上記のコードをCopyFile.javaファイルに入れて、次のようにします。
$javac CopyFile.java $java CopyFile
キャラクターストリーム
Java Byte ストリームは8ビットバイトの入出力を実行するために使用されますが、Javaは Characterストリームは、16ビットUnicodeの入力と出力を実行するために使用されます。文字ストリームに関連するクラスはたくさんありますが、最も頻繁に使用されるクラスは、FileReader そして FileWriter。内部的にはFileReaderはFileInputStreamを使用し、FileWriterはFileOutputStreamを使用しますが、ここでの主な違いは、FileReaderが一度に2バイトを読み取り、FileWriterが一度に2バイトを書き込むことです。
上記の例を書き直すことができます。これは、これら2つのクラスを使用して、入力ファイル(Unicode文字を含む)を出力ファイルにコピーします。
Example
import java.io.*;
public class CopyFile {
public static void main(String args[]) throws IOException {
FileReader in = null;
FileWriter out = null;
try {
in = new FileReader("input.txt");
out = new FileWriter("output.txt");
int c;
while ((c = in.read()) != -1) {
out.write(c);
}
}finally {
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}
}
}
それではファイルを作成しましょう input.txt 次の内容で-
This is test for copy file.
次のステップとして、上記のプログラムをコンパイルして実行します。これにより、input.txtと同じ内容のoutput.txtファイルが作成されます。それでは、上記のコードをCopyFile.javaファイルに入れて、次のようにします。
$javac CopyFile.java $java CopyFile
標準ストリーム
すべてのプログラミング言語は、ユーザーのプログラムがキーボードから入力を受け取り、コンピューター画面に出力を生成できる標準I / Oのサポートを提供します。CまたはC ++プログラミング言語を知っている場合は、3つの標準デバイスSTDIN、STDOUT、およびSTDERRを知っている必要があります。同様に、Javaは次の3つの標準ストリームを提供します-
Standard Input −これは、データをユーザーのプログラムに供給するために使用され、通常、キーボードは標準入力ストリームとして使用され、次のように表されます。 System.in。
Standard Output −これは、ユーザーのプログラムによって生成されたデータを出力するために使用され、通常、コンピューター画面が標準出力ストリームに使用され、次のように表されます。 System.out。
Standard Error −これは、ユーザーのプログラムによって生成されたエラーデータを出力するために使用され、通常、コンピューター画面が標準エラーストリームに使用され、次のように表されます。 System.err。
以下は、作成する簡単なプログラムです InputStreamReader ユーザーが「q」を入力するまで標準入力ストリームを読み取る-
Example
import java.io.*;
public class ReadConsole {
public static void main(String args[]) throws IOException {
InputStreamReader cin = null;
try {
cin = new InputStreamReader(System.in);
System.out.println("Enter characters, 'q' to quit.");
char c;
do {
c = (char) cin.read();
System.out.print(c);
} while(c != 'q');
}finally {
if (cin != null) {
cin.close();
}
}
}
}
上記のコードをReadConsole.javaファイルに保存し、次のプログラムに示すようにコンパイルして実行してみましょう。このプログラムは、「q」を押すまで同じ文字を読み取り、出力し続けます。
$javac ReadConsole.java $java ReadConsole
Enter characters, 'q' to quit.
1
1
e
e
q
q
ファイルの読み取りと書き込み
前に説明したように、ストリームはデータのシーケンスとして定義できます。ザ・InputStream ソースからデータを読み取るために使用され、 OutputStream 宛先にデータを書き込むために使用されます。
入力ストリームと出力ストリームを処理するクラスの階層は次のとおりです。
2つの重要なストリームは FileInputStream そして FileOutputStream、このチュートリアルで説明します。
FileInputStream
このストリームは、ファイルからデータを読み取るために使用されます。キーワードを使用してオブジェクトを作成できますnew 利用可能なコンストラクターにはいくつかの種類があります。
次のコンストラクターは、ファイル名を文字列として受け取り、ファイルを読み取るための入力ストリームオブジェクトを作成します-
InputStream f = new FileInputStream("C:/java/hello");
次のコンストラクターは、ファイルオブジェクトを取得して、ファイルを読み取るための入力ストリームオブジェクトを作成します。まず、次のようにFile()メソッドを使用してファイルオブジェクトを作成します。
File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);
あなたが持っている一度のInputStream手にオブジェクトを、そのストリームに読み込んだり、ストリーム上で他の操作を行うために使用することができるヘルパーメソッドの一覧があります。
シニア番号 | 方法と説明 |
---|---|
1 | public void close() throws IOException{} このメソッドは、ファイル出力ストリームを閉じます。ファイルに関連付けられているシステムリソースを解放します。IOExceptionをスローします。 |
2 | protected void finalize()throws IOException {} このメソッドは、ファイルへの接続をクリーンアップします。このストリームへの参照がなくなったときに、このファイル出力ストリームのcloseメソッドが呼び出されるようにします。IOExceptionをスローします。 |
3 | public int read(int r)throws IOException{} このメソッドは、指定されたバイトのデータをInputStreamから読み取ります。intを返します。データの次のバイトを返します。ファイルの終わりの場合は-1が返されます。 |
4 | public int read(byte[] r) throws IOException{} このメソッドは、入力ストリームから配列にr.lengthバイトを読み取ります。読み取られた合計バイト数を返します。ファイルの終わりの場合は、-1が返されます。 |
5 | public int available() throws IOException{} このファイル入力ストリームから読み取ることができるバイト数を示します。intを返します。 |
利用可能な他の重要な入力ストリームがあります。詳細については、次のリンクを参照してください-
ByteArrayInputStream
DataInputStream
FileOutputStream
FileOutputStreamは、ファイルを作成してデータを書き込むために使用されます。ストリームは、ファイルを出力用に開く前に、ファイルがまだ存在しない場合は作成します。
FileOutputStreamオブジェクトを作成するために使用できる2つのコンストラクターを次に示します。
次のコンストラクターは、ファイル名を文字列として受け取り、ファイルを書き込むための入力ストリームオブジェクトを作成します-
OutputStream f = new FileOutputStream("C:/java/hello")
次のコンストラクターは、ファイルオブジェクトを取得して、ファイルを書き込むための出力ストリームオブジェクトを作成します。まず、次のようにFile()メソッドを使用してファイルオブジェクトを作成します。
File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);
あなたが持ってたらOutputStreamの手で物を、その後、ストリーミングしたり、ストリーム上で他の操作を行うために、書き込みに使用することができヘルパーメソッドのリストは、そこにあります。
シニア番号 | 方法と説明 |
---|---|
1 | public void close() throws IOException{} このメソッドは、ファイル出力ストリームを閉じます。ファイルに関連付けられているシステムリソースを解放します。IOExceptionをスローします。 |
2 | protected void finalize()throws IOException {} このメソッドは、ファイルへの接続をクリーンアップします。このストリームへの参照がなくなったときに、このファイル出力ストリームのcloseメソッドが呼び出されるようにします。IOExceptionをスローします。 |
3 | public void write(int w)throws IOException{} このメソッドは、指定されたバイトを出力ストリームに書き込みます。 |
4 | public void write(byte[] w) 上記のバイト配列からOutputStreamにw.lengthバイトを書き込みます。 |
利用可能な他の重要な出力ストリームがあります。詳細については、次のリンクを参照してください-
ByteArrayOutputStream
DataOutputStream
Example
以下は、InputStreamとOutputStreamを示す例です-
import java.io.*;
public class fileStreamTest {
public static void main(String args[]) {
try {
byte bWrite [] = {11,21,3,40,5};
OutputStream os = new FileOutputStream("test.txt");
for(int x = 0; x < bWrite.length ; x++) {
os.write( bWrite[x] ); // writes the bytes
}
os.close();
InputStream is = new FileInputStream("test.txt");
int size = is.available();
for(int i = 0; i < size; i++) {
System.out.print((char)is.read() + " ");
}
is.close();
} catch (IOException e) {
System.out.print("Exception");
}
}
}
上記のコードは、ファイルtest.txtを作成し、指定された数値をバイナリ形式で書き込みます。stdout画面の出力も同じです。
ファイルナビゲーションとI / O
ファイルナビゲーションとI / Oの基本を理解するために、他にもいくつかのクラスを受講します。
ファイルクラス
FileReaderクラス
FileWriterクラス
Javaのディレクトリ
ディレクトリは、他のファイルやディレクトリのリストを含めることができるファイルです。あなたが使うFileディレクトリを作成し、ディレクトリで使用可能なファイルを一覧表示するオブジェクト。詳細については、Fileオブジェクトで呼び出すことができるすべてのメソッドと、ディレクトリに関連するもののリストを確認してください。
ディレクトリの作成
2つの便利なものがあります File ディレクトリの作成に使用できるユーティリティメソッド-
ザ・ mkdir( )メソッドはディレクトリを作成し、成功した場合はtrueを返し、失敗した場合はfalseを返します。失敗は、Fileオブジェクトで指定されたパスがすでに存在するか、パス全体がまだ存在しないためにディレクトリを作成できないことを示します。
ザ・ mkdirs() メソッドは、ディレクトリとディレクトリのすべての親の両方を作成します。
次の例では、「/ tmp / user / java / bin」ディレクトリを作成します-
Example
import java.io.File;
public class CreateDir {
public static void main(String args[]) {
String dirname = "/tmp/user/java/bin";
File d = new File(dirname);
// Create directory now.
d.mkdirs();
}
}
上記のコードをコンパイルして実行し、「/ tmp / user / java / bin」を作成します。
Note− Javaは、慣例に従って、UNIXおよびWindowsのパス区切り文字を自動的に処理します。WindowsバージョンのJavaでスラッシュ(/)を使用する場合でも、パスは正しく解決されます。
ディレクトリの一覧表示
使用できます list( ) によって提供される方法 File 次のように、ディレクトリで使用可能なすべてのファイルとディレクトリを一覧表示するオブジェクト-
Example
import java.io.File;
public class ReadDir {
public static void main(String[] args) {
File file = null;
String[] paths;
try {
// create new file object
file = new File("/tmp");
// array of files and directory
paths = file.list();
// for each name in the path array
for(String path:paths) {
// prints filename and directory name
System.out.println(path);
}
} catch (Exception e) {
// if any error occurs
e.printStackTrace();
}
}
}
これにより、で使用可能なディレクトリとファイルに基づいて、次の結果が生成されます。 /tmp ディレクトリ-
Output
test1.txt
test2.txt
ReadDir.java
ReadDir.class
例外(または例外イベント)は、プログラムの実行中に発生する問題です。いつException プログラムの通常のフローが中断され、プログラム/アプリケーションが異常終了することが発生します。これはお勧めできません。したがって、これらの例外を処理する必要があります。
例外はさまざまな理由で発生する可能性があります。以下は、例外が発生するいくつかのシナリオです。
ユーザーが無効なデータを入力しました。
開く必要のあるファイルが見つかりません。
通信の途中でネットワーク接続が失われたか、JVMのメモリが不足しています。
これらの例外には、ユーザーエラー、プログラマーエラー、および何らかの方法で障害が発生した物理リソースが原因で発生するものがあります。
これらに基づいて、例外の3つのカテゴリがあります。Javaで例外処理がどのように機能するかを知るには、それらを理解する必要があります。
Checked exceptions−チェック例外は、コンパイル時にコンパイラによってチェック(通知)される例外であり、コンパイル時例外とも呼ばれます。これらの例外は単純に無視することはできません。プログラマーはこれらの例外を処理(処理)する必要があります。
たとえば、 FileReaderプログラム内のクラスでファイルからデータを読み取る場合、コンストラクターで指定されたファイルが存在しない場合、FileNotFoundExceptionが発生し、コンパイラーはプログラマーに例外の処理を要求します。
例
import java.io.File;
import java.io.FileReader;
public class FilenotFound_Demo {
public static void main(String args[]) {
File file = new File("E://file.txt");
FileReader fr = new FileReader(file);
}
}
上記のプログラムをコンパイルしようとすると、次の例外が発生します。
出力
C:\>javac FilenotFound_Demo.java
FilenotFound_Demo.java:8: error: unreported exception FileNotFoundException; must be caught or declared to be thrown
FileReader fr = new FileReader(file);
^
1 error
Note −メソッド以来 read() そして close() FileReaderクラスがIOExceptionをスローすると、コンパイラがFileNotFoundExceptionとともにIOExceptionを処理するように通知することがわかります。
Unchecked exceptions−チェックされていない例外は、実行時に発生する例外です。これらは、Runtime Exceptions。これには、論理エラーやAPIの不適切な使用などのプログラミングのバグが含まれます。実行時の例外は、コンパイル時に無視されます。
たとえば、プログラムでサイズ5の配列を宣言し、配列の6番目の要素を呼び出そうとすると、ArrayIndexOutOfBoundsExceptionexceptionが発生します。
例
public class Unchecked_Demo {
public static void main(String args[]) {
int num[] = {1, 2, 3, 4};
System.out.println(num[5]);
}
}
上記のプログラムをコンパイルして実行すると、次の例外が発生します。
出力
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
at Exceptions.Unchecked_Demo.main(Unchecked_Demo.java:8)
Errors−これらはまったく例外ではありませんが、ユーザーまたはプログラマーの制御を超えて発生する問題です。エラーについてはほとんど何もできないため、エラーは通常、コードでは無視されます。たとえば、スタックオーバーフローが発生すると、エラーが発生します。また、コンパイル時には無視されます。
例外階層
すべての例外クラスは、java.lang.Exceptionクラスのサブタイプです。例外クラスは、Throwableクラスのサブクラスです。例外クラスの他に、Throwableクラスから派生したErrorと呼ばれる別のサブクラスがあります。
エラーは、重大な障害が発生した場合に発生する異常な状態であり、Javaプログラムでは処理されません。エラーは、ランタイム環境によって生成されたエラーを示すために生成されます。例:JVMのメモリが不足しています。通常、プログラムはエラーから回復できません。
Exceptionクラスには、IOExceptionクラスとRuntimeExceptionクラスの2つの主要なサブクラスがあります。
以下は、最も一般的なチェック済みおよびチェックなしのJavaの組み込み例外のリストです。
例外メソッド
以下は、Throwableクラスで使用可能な重要なメソッドのリストです。
シニア番号 | 方法と説明 |
---|---|
1 | public String getMessage() 発生した例外に関する詳細メッセージを返します。このメッセージは、Throwableコンストラクターで初期化されます。 |
2 | public Throwable getCause() Throwableオブジェクトで表される例外の原因を返します。 |
3 | public String toString() getMessage()の結果と連結されたクラスの名前を返します。 |
4 | public void printStackTrace() toString()の結果をスタックトレースとともにエラー出力ストリームであるSystem.errに出力します。 |
5 | public StackTraceElement [] getStackTrace() スタックトレース上の各要素を含む配列を返します。インデックス0の要素は呼び出しスタックの最上位を表し、配列の最後の要素は呼び出しスタックの最下部のメソッドを表します。 |
6 | public Throwable fillInStackTrace() このThrowableオブジェクトのスタックトレースを現在のスタックトレースで埋め、スタックトレースの以前の情報に追加します。 |
例外をキャッチする
メソッドは、との組み合わせを使用して例外をキャッチします try そして catchキーワード。例外を生成する可能性のあるコードの周囲にtry / catchブロックが配置されます。try / catchブロック内のコードは保護されたコードと呼ばれ、try / catchを使用するための構文は次のようになります。
構文
try {
// Protected code
} catch (ExceptionName e1) {
// Catch block
}
例外が発生しやすいコードは、tryブロックに配置されます。例外が発生すると、発生したその例外は、それに関連付けられたcatchブロックによって処理されます。すべてのtryブロックの直後に、catchブロックまたはfinallyブロックが続く必要があります。
catchステートメントには、キャッチしようとしている例外のタイプを宣言することが含まれます。保護されたコードで例外が発生した場合、試行に続く1つまたは複数のcatchブロックがチェックされます。発生した例外のタイプがcatchブロックにリストされている場合、引数がメソッドパラメーターに渡されるのと同じように、例外がcatchブロックに渡されます。
例
以下は、2つの要素で宣言された配列です。次に、コードは例外をスローする配列の3番目の要素にアクセスしようとします。
// File Name : ExcepTest.java
import java.io.*;
public class ExcepTest {
public static void main(String args[]) {
try {
int a[] = new int[2];
System.out.println("Access element three :" + a[3]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Exception thrown :" + e);
}
System.out.println("Out of the block");
}
}
これにより、次の結果が生成されます-
出力
Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block
複数のキャッチブロック
tryブロックの後に複数のcatchブロックを続けることができます。複数のcatchブロックの構文は次のようになります-
構文
try {
// Protected code
} catch (ExceptionType1 e1) {
// Catch block
} catch (ExceptionType2 e2) {
// Catch block
} catch (ExceptionType3 e3) {
// Catch block
}
前のステートメントは3つのキャッチブロックを示していますが、1回の試行で任意の数のキャッチブロックを使用できます。保護されたコードで例外が発生した場合、例外はリストの最初のcatchブロックにスローされます。スローされた例外のデータ型がExceptionType1と一致する場合、そこでキャッチされます。そうでない場合、例外は2番目のcatchステートメントに渡されます。これは、例外がキャッチされるか、すべてのキャッチを通過するまで続きます。その場合、現在のメソッドは実行を停止し、例外は呼び出しスタック上の前のメソッドにスローされます。
例
これは、複数のtry / catchステートメントの使用方法を示すコードセグメントです。
try {
file = new FileInputStream(fileName);
x = (byte) file.read();
} catch (IOException i) {
i.printStackTrace();
return -1;
} catch (FileNotFoundException f) // Not valid! {
f.printStackTrace();
return -1;
}
複数のタイプの例外をキャッチする
Java 7以降、単一のcatchブロックを使用して複数の例外を処理できるため、この機能によりコードが簡素化されます。これがあなたがそれをする方法です-
catch (IOException|FileNotFoundException ex) {
logger.log(ex);
throw ex;
スロー/スローキーワード
メソッドがチェックされた例外を処理しない場合、メソッドはを使用してそれを宣言する必要があります throwsキーワード。throwsキーワードは、メソッドのシグネチャの最後に表示されます。
を使用して、新しくインスタンス化された例外またはキャッチしたばかりの例外のいずれかの例外をスローできます。 throw キーワード。
throwsキーワードとthrowキーワードの違いを理解してください。throwsはチェックされた例外の処理を延期するために使用され、throwは例外を明示的に呼び出すために使用されます。
次のメソッドは、RemoteExceptionをスローすることを宣言します-
例
import java.io.*;
public class className {
public void deposit(double amount) throws RemoteException {
// Method implementation
throw new RemoteException();
}
// Remainder of class definition
}
メソッドは、複数の例外をスローすることを宣言できます。その場合、例外はコンマで区切られたリストで宣言されます。たとえば、次のメソッドは、RemoteExceptionとInsufficientFundsExceptionをスローすることを宣言しています-
例
import java.io.*;
public class className {
public void withdraw(double amount) throws RemoteException,
InsufficientFundsException {
// Method implementation
}
// Remainder of class definition
}
最後にブロック
finalブロックは、tryブロックまたはcatchブロックの後に続きます。例外の発生に関係なく、コードのfinallyブロックは常に実行されます。
finishブロックを使用すると、保護されたコードで何が起こっても、実行したいクリーンアップタイプのステートメントを実行できます。
finishブロックは、catchブロックの最後に表示され、次の構文になります。
構文
try {
// Protected code
} catch (ExceptionType1 e1) {
// Catch block
} catch (ExceptionType2 e2) {
// Catch block
} catch (ExceptionType3 e3) {
// Catch block
}finally {
// The finally block always executes.
}
例
public class ExcepTest {
public static void main(String args[]) {
int a[] = new int[2];
try {
System.out.println("Access element three :" + a[3]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Exception thrown :" + e);
}finally {
a[0] = 6;
System.out.println("First element value: " + a[0]);
System.out.println("The finally statement is executed");
}
}
}
これにより、次の結果が生成されます-
出力
Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3
First element value: 6
The finally statement is executed
次の点に注意してください-
catch句は、tryステートメントなしでは存在できません。
try / catchブロックが存在する場合は常に、finally句を含める必要はありません。
tryブロックは、catch句またはfinally句なしでは存在できません。
try、catch、finallyブロックの間にコードを含めることはできません。
リソースを試す
一般に、ストリームや接続などのリソースを使用する場合は、finallyブロックを使用して明示的に閉じる必要があります。次のプログラムでは、を使用してファイルからデータを読み取っています。FileReader そしてfinallyブロックを使用して閉じています。
例
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class ReadData_Demo {
public static void main(String args[]) {
FileReader fr = null;
try {
File file = new File("file.txt");
fr = new FileReader(file); char [] a = new char[50];
fr.read(a); // reads the content to the array
for(char c : a)
System.out.print(c); // prints the characters one by one
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fr.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
}
try-with-resources、とも呼ばれます automatic resource managementは、Java 7で導入された新しい例外処理メカニズムであり、trycatchブロック内で使用されているリソースを自動的に閉じます。
このステートメントを使用するには、括弧内に必要なリソースを宣言するだけで、作成されたリソースはブロックの最後で自動的に閉じられます。以下は、try-with-resourcesステートメントの構文です。
構文
try(FileReader fr = new FileReader("file path")) {
// use the resource
} catch () {
// body of catch
}
}
以下は、try-with-resourcesステートメントを使用してファイル内のデータを読み取るプログラムです。
例
import java.io.FileReader;
import java.io.IOException;
public class Try_withDemo {
public static void main(String args[]) {
try(FileReader fr = new FileReader("E://file.txt")) {
char [] a = new char[50];
fr.read(a); // reads the contentto the array
for(char c : a)
System.out.print(c); // prints the characters one by one
} catch (IOException e) {
e.printStackTrace();
}
}
}
try-with-resourcesステートメントを使用するときは、次の点に注意してください。
try-with-resourcesステートメントでクラスを使用するには、実装する必要があります AutoCloseable インターフェースと close() そのメソッドは実行時に自動的に呼び出されます。
try-with-resourcesステートメントで複数のクラスを宣言できます。
try-with-resourcesステートメントのtryブロックで複数のクラスを宣言している間、これらのクラスは逆の順序で閉じられます。
括弧内のリソースの宣言を除いて、すべてがtryブロックの通常のtry / catchブロックと同じです。
tryで宣言されたリソースは、try-blockの開始直前にインスタンス化されます。
tryブロックで宣言されたリソースは、暗黙的にfinalとして宣言されます。
ユーザー定義の例外
Javaで独自の例外を作成できます。独自の例外クラスを作成するときは、次の点に注意してください。
すべての例外はThrowableの子である必要があります。
HandleまたはDeclareRuleによって自動的に適用されるチェック済み例外を作成する場合は、Exceptionクラスを拡張する必要があります。
ランタイム例外を記述したい場合は、RuntimeExceptionクラスを拡張する必要があります。
独自のExceptionクラスを次のように定義できます-
class MyException extends Exception {
}
事前定義されたものを拡張する必要があります Exception独自の例外を作成するクラス。これらはチェックされた例外と見なされます。以下InsufficientFundsExceptionclassは、Exceptionクラスを拡張するユーザー定義の例外であり、チェックされた例外になります。例外クラスは他のクラスと同様で、便利なフィールドとメソッドが含まれています。
例
// File Name InsufficientFundsException.java
import java.io.*;
public class InsufficientFundsException extends Exception {
private double amount;
public InsufficientFundsException(double amount) {
this.amount = amount;
}
public double getAmount() {
return amount;
}
}
ユーザー定義の例外の使用を示すために、次のCheckingAccountクラスには、InsufficientFundsExceptionをスローするwithdraw()メソッドが含まれています。
// File Name CheckingAccount.java
import java.io.*;
public class CheckingAccount {
private double balance;
private int number;
public CheckingAccount(int number) {
this.number = number;
}
public void deposit(double amount) {
balance += amount;
}
public void withdraw(double amount) throws InsufficientFundsException {
if(amount <= balance) {
balance -= amount;
}else {
double needs = amount - balance;
throw new InsufficientFundsException(needs);
}
}
public double getBalance() {
return balance;
}
public int getNumber() {
return number;
}
}
次のBankDemoプログラムは、CheckingAccountのdeposit()メソッドとwithdraw()メソッドの呼び出しを示しています。
// File Name BankDemo.java
public class BankDemo {
public static void main(String [] args) {
CheckingAccount c = new CheckingAccount(101);
System.out.println("Depositing $500..."); c.deposit(500.00); try { System.out.println("\nWithdrawing $100...");
c.withdraw(100.00);
System.out.println("\nWithdrawing $600..."); c.withdraw(600.00); } catch (InsufficientFundsException e) { System.out.println("Sorry, but you are short $" + e.getAmount());
e.printStackTrace();
}
}
}
上記の3つのファイルをすべてコンパイルし、BankDemoを実行します。これにより、次の結果が生成されます-
出力
Depositing $500... Withdrawing $100...
Withdrawing $600... Sorry, but you are short $200.0
InsufficientFundsException
at CheckingAccount.withdraw(CheckingAccount.java:25)
at BankDemo.main(BankDemo.java:13)
一般的な例外
Javaでは、例外とエラーの2つのカテゴリを定義できます。
JVM Exceptions−これらは、JVMによって排他的または論理的にスローされる例外/エラーです。例:NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException。
Programmatic Exceptions−これらの例外は、アプリケーションまたはAPIプログラマーによって明示的にスローされます。例:IllegalArgumentException、IllegalStateException。
この章では、Javaの内部クラスについて説明します。
ネストされたクラス
Javaでは、メソッドと同様に、クラスの変数もそのメンバーとして別のクラスを持つことができます。別のクラス内にクラスを書き込むことは、Javaで許可されています。内に書かれたクラスはと呼ばれますnested class、および内部クラスを保持するクラスは、 outer class。
Syntax
Following is the syntax to write a nested class. Here, the class Outer_Demo is the outer class and the class Inner_Demo is the nested class.
class Outer_Demo {
class Inner_Demo {
}
}
Nested classes are divided into two types −
Non-static nested classes − These are the non-static members of a class.
Static nested classes − These are the static members of a class.
Inner Classes (Non-static Nested Classes)
Inner classes are a security mechanism in Java. We know a class cannot be associated with the access modifier private, but if we have the class as a member of other class, then the inner class can be made private. And this is also used to access the private members of a class.
Inner classes are of three types depending on how and where you define them. They are −
- Inner Class
- Method-local Inner Class
- Anonymous Inner Class
Inner Class
Creating an inner class is quite simple. You just need to write a class within a class. Unlike a class, an inner class can be private and once you declare an inner class private, it cannot be accessed from an object outside the class.
Following is the program to create an inner class and access it. In the given example, we make the inner class private and access the class through a method.
Example
class Outer_Demo {
int num;
// inner class
private class Inner_Demo {
public void print() {
System.out.println("This is an inner class");
}
}
// Accessing he inner class from the method within
void display_Inner() {
Inner_Demo inner = new Inner_Demo();
inner.print();
}
}
public class My_class {
public static void main(String args[]) {
// Instantiating the outer class
Outer_Demo outer = new Outer_Demo();
// Accessing the display_Inner() method.
outer.display_Inner();
}
}
Here you can observe that Outer_Demo is the outer class, Inner_Demo is the inner class, display_Inner() is the method inside which we are instantiating the inner class, and this method is invoked from the main method.
If you compile and execute the above program, you will get the following result −
Output
This is an inner class.
Accessing the Private Members
As mentioned earlier, inner classes are also used to access the private members of a class. Suppose, a class is having private members to access them. Write an inner class in it, return the private members from a method within the inner class, say, getValue(), and finally from another class (from which you want to access the private members) call the getValue() method of the inner class.
To instantiate the inner class, initially you have to instantiate the outer class. Thereafter, using the object of the outer class, following is the way in which you can instantiate the inner class.
Outer_Demo outer = new Outer_Demo();
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
The following program shows how to access the private members of a class using inner class.
Example
class Outer_Demo {
// private variable of the outer class
private int num = 175;
// inner class
public class Inner_Demo {
public int getNum() {
System.out.println("This is the getnum method of the inner class");
return num;
}
}
}
public class My_class2 {
public static void main(String args[]) {
// Instantiating the outer class
Outer_Demo outer = new Outer_Demo();
// Instantiating the inner class
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
System.out.println(inner.getNum());
}
}
If you compile and execute the above program, you will get the following result −
Output
This is the getnum method of the inner class: 175
Method-local Inner Class
In Java, we can write a class within a method and this will be a local type. Like local variables, the scope of the inner class is restricted within the method.
A method-local inner class can be instantiated only within the method where the inner class is defined. The following program shows how to use a method-local inner class.
Example
public class Outerclass {
// instance method of the outer class
void my_Method() {
int num = 23;
// method-local inner class
class MethodInner_Demo {
public void print() {
System.out.println("This is method inner class "+num);
}
} // end of inner class
// Accessing the inner class
MethodInner_Demo inner = new MethodInner_Demo();
inner.print();
}
public static void main(String args[]) {
Outerclass outer = new Outerclass();
outer.my_Method();
}
}
If you compile and execute the above program, you will get the following result −
Output
This is method inner class 23
Anonymous Inner Class
An inner class declared without a class name is known as an anonymous inner class. In case of anonymous inner classes, we declare and instantiate them at the same time. Generally, they are used whenever you need to override the method of a class or an interface. The syntax of an anonymous inner class is as follows −
Syntax
AnonymousInner an_inner = new AnonymousInner() {
public void my_method() {
........
........
}
};
The following program shows how to override the method of a class using anonymous inner class.
Example
abstract class AnonymousInner {
public abstract void mymethod();
}
public class Outer_class {
public static void main(String args[]) {
AnonymousInner inner = new AnonymousInner() {
public void mymethod() {
System.out.println("This is an example of anonymous inner class");
}
};
inner.mymethod();
}
}
If you compile and execute the above program, you will get the following result −
Output
This is an example of anonymous inner class
In the same way, you can override the methods of the concrete class as well as the interface using an anonymous inner class.
Anonymous Inner Class as Argument
Generally, if a method accepts an object of an interface, an abstract class, or a concrete class, then we can implement the interface, extend the abstract class, and pass the object to the method. If it is a class, then we can directly pass it to the method.
But in all the three cases, you can pass an anonymous inner class to the method. Here is the syntax of passing an anonymous inner class as a method argument −
obj.my_Method(new My_Class() {
public void Do() {
.....
.....
}
});
The following program shows how to pass an anonymous inner class as a method argument.
Example
// interface
interface Message {
String greet();
}
public class My_class {
// method which accepts the object of interface Message
public void displayMessage(Message m) {
System.out.println(m.greet() +
", This is an example of anonymous inner class as an argument");
}
public static void main(String args[]) {
// Instantiating the class
My_class obj = new My_class();
// Passing an anonymous inner class as an argument
obj.displayMessage(new Message() {
public String greet() {
return "Hello";
}
});
}
}
If you compile and execute the above program, it gives you the following result −
Output
Hello, This is an example of anonymous inner class as an argument
Static Nested Class
A static inner class is a nested class which is a static member of the outer class. It can be accessed without instantiating the outer class, using other static members. Just like static members, a static nested class does not have access to the instance variables and methods of the outer class. The syntax of static nested class is as follows −
Syntax
class MyOuter {
static class Nested_Demo {
}
}
Instantiating a static nested class is a bit different from instantiating an inner class. The following program shows how to use a static nested class.
Example
public class Outer {
static class Nested_Demo {
public void my_method() {
System.out.println("This is my nested class");
}
}
public static void main(String args[]) {
Outer.Nested_Demo nested = new Outer.Nested_Demo();
nested.my_method();
}
}
If you compile and execute the above program, you will get the following result −
Output
This is my nested class
Inheritance can be defined as the process where one class acquires the properties (methods and fields) of another. With the use of inheritance the information is made manageable in a hierarchical order.
The class which inherits the properties of other is known as subclass (derived class, child class) and the class whose properties are inherited is known as superclass (base class, parent class).
extends Keyword
extends is the keyword used to inherit the properties of a class. Following is the syntax of extends keyword.
Syntax
class Super {
.....
.....
}
class Sub extends Super {
.....
.....
}
Sample Code
Following is an example demonstrating Java inheritance. In this example, you can observe two classes namely Calculation and My_Calculation.
Using extends keyword, the My_Calculation inherits the methods addition() and Subtraction() of Calculation class.
Copy and paste the following program in a file with name My_Calculation.java
Example
class Calculation {
int z;
public void addition(int x, int y) {
z = x + y;
System.out.println("The sum of the given numbers:"+z);
}
public void Subtraction(int x, int y) {
z = x - y;
System.out.println("The difference between the given numbers:"+z);
}
}
public class My_Calculation extends Calculation {
public void multiplication(int x, int y) {
z = x * y;
System.out.println("The product of the given numbers:"+z);
}
public static void main(String args[]) {
int a = 20, b = 10;
My_Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);
demo.multiplication(a, b);
}
}
Compile and execute the above code as shown below.
javac My_Calculation.java
java My_Calculation
After executing the program, it will produce the following result −
Output
The sum of the given numbers:30
The difference between the given numbers:10
The product of the given numbers:200
In the given program, when an object to My_Calculation class is created, a copy of the contents of the superclass is made within it. That is why, using the object of the subclass you can access the members of a superclass.
The Superclass reference variable can hold the subclass object, but using that variable you can access only the members of the superclass, so to access the members of both classes it is recommended to always create reference variable to the subclass.
If you consider the above program, you can instantiate the class as given below. But using the superclass reference variable ( cal in this case) you cannot call the method multiplication(), which belongs to the subclass My_Calculation.
Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);
Note−サブクラスは、そのスーパークラスからすべてのメンバー(フィールド、メソッド、およびネストされたクラス)を継承します。コンストラクターはメンバーではないため、サブクラスには継承されませんが、スーパークラスのコンストラクターはサブクラスから呼び出すことができます。
スーパーキーワード
ザ・ super キーワードはに似ています thisキーワード。以下は、superキーワードが使用されるシナリオです。
それはに慣れています differentiate the members 同じ名前の場合、サブクラスのメンバーからのスーパークラスの。
それはに慣れています invoke the superclass サブクラスからのコンストラクタ。
メンバーの差別化
クラスが別のクラスのプロパティを継承している場合。また、スーパークラスのメンバーの名前がサブクラスと同じである場合、これらの変数を区別するために、以下に示すようにスーパーキーワードを使用します。
super.variable
super.method();
サンプルコード
このセクションでは、の使用法を示すプログラムを提供します。 super キーワード。
指定されたプログラムには、Sub_classとSuper_classという2つのクラスがあり、どちらにも実装が異なるdisplay()という名前のメソッドと、値が異なるnumという名前の変数があります。両方のクラスのdisplay()メソッドを呼び出し、両方のクラスの変数numの値を出力しています。ここでは、スーパーキーワードを使用してスーパークラスのメンバーとサブクラスを区別していることがわかります。
プログラムをコピーして、Sub_class.javaという名前のファイルに貼り付けます。
Example
class Super_class {
int num = 20;
// display method of superclass
public void display() {
System.out.println("This is the display method of superclass");
}
}
public class Sub_class extends Super_class {
int num = 10;
// display method of sub class
public void display() {
System.out.println("This is the display method of subclass");
}
public void my_method() {
// Instantiating subclass
Sub_class sub = new Sub_class();
// Invoking the display() method of sub class
sub.display();
// Invoking the display() method of superclass
super.display();
// printing the value of variable num of subclass
System.out.println("value of the variable named num in sub class:"+ sub.num);
// printing the value of variable num of superclass
System.out.println("value of the variable named num in super class:"+ super.num);
}
public static void main(String args[]) {
Sub_class obj = new Sub_class();
obj.my_method();
}
}
次の構文を使用して、上記のコードをコンパイルして実行します。
javac Super_Demo
java Super
プログラムを実行すると、次の結果が得られます-
Output
This is the display method of subclass
This is the display method of superclass
value of the variable named num in sub class:10
value of the variable named num in super class:20
スーパークラスコンストラクターの呼び出し
クラスが別のクラスのプロパティを継承している場合、サブクラスはスーパークラスのデフォルトコンストラクターを自動的に取得します。ただし、スーパークラスのパラメーター化されたコンストラクターを呼び出す場合は、以下に示すようにsuperキーワードを使用する必要があります。
super(values);
サンプルコード
このセクションに記載されているプログラムは、superキーワードを使用してスーパークラスのParameterizedコンストラクターを呼び出す方法を示しています。このプログラムには、スーパークラスとサブクラスが含まれています。スーパークラスには、整数値を受け入れるパラメーター化されたコンストラクターが含まれており、superキーワードを使用して、スーパークラスのパラメーター化されたコンストラクターを呼び出しました。
次のプログラムをコピーして、Subclass.javaという名前のファイルに貼り付けます。
Example
class Superclass {
int age;
Superclass(int age) {
this.age = age;
}
public void getAge() {
System.out.println("The value of the variable named age in super class is: " +age);
}
}
public class Subclass extends Superclass {
Subclass(int age) {
super(age);
}
public static void main(String args[]) {
Subclass s = new Subclass(24);
s.getAge();
}
}
次の構文を使用して、上記のコードをコンパイルして実行します。
javac Subclass
java Subclass
プログラムを実行すると、次の結果が得られます-
Output
The value of the variable named age in super class is: 24
IS-Aの関係
IS-Aは言い方です:このオブジェクトはそのオブジェクトの一種です。どのようにextends キーワードは継承を実現するために使用されます。
public class Animal {
}
public class Mammal extends Animal {
}
public class Reptile extends Animal {
}
public class Dog extends Mammal {
}
さて、上記の例に基づいて、オブジェクト指向の用語では、次のことが当てはまります-
- 動物は哺乳類クラスのスーパークラスです。
- 動物は爬虫類クラスのスーパークラスです。
- 哺乳類と爬虫類は動物クラスのサブクラスです。
- 犬は哺乳類と動物の両方のクラスのサブクラスです。
さて、IS-Aの関係を考えると、次のように言えます。
- 哺乳類IS-動物
- 爬虫類IS-動物
- 犬IS-哺乳類
- したがって:犬は動物でもあります
extendsキーワードを使用すると、サブクラスは、スーパークラスのプライベートプロパティを除いて、スーパークラスのすべてのプロパティを継承できます。
インスタンス演算子を使用すると、哺乳類が実際に動物であることを確認できます。
Example
class Animal {
}
class Mammal extends Animal {
}
class Reptile extends Animal {
}
public class Dog extends Mammal {
public static void main(String args[]) {
Animal a = new Animal();
Mammal m = new Mammal();
Dog d = new Dog();
System.out.println(m instanceof Animal);
System.out.println(d instanceof Mammal);
System.out.println(d instanceof Animal);
}
}
これにより、次の結果が生成されます-
Output
true
true
true
私たちはよく理解しているので extends キーワード、どのように見てみましょう implements キーワードは、IS-A関係を取得するために使用されます。
一般的に、 implementsキーワードは、インターフェイスのプロパティを継承するためにクラスで使用されます。インターフェースをクラスで拡張することはできません。
Example
public interface Animal {
}
public class Mammal implements Animal {
}
public class Dog extends Mammal {
}
キーワードのインスタンス
使用しましょう instanceof 哺乳類が実際に動物であり、犬が実際に動物であるかどうかを確認するオペレーター。
Example
interface Animal{}
class Mammal implements Animal{}
public class Dog extends Mammal {
public static void main(String args[]) {
Mammal m = new Mammal();
Dog d = new Dog();
System.out.println(m instanceof Animal);
System.out.println(d instanceof Mammal);
System.out.println(d instanceof Animal);
}
}
これにより、次の結果が生成されます-
Output
true
true
true
HAS-関係
これらの関係は、主に使用法に基づいています。これは、特定のクラスかどうかを決定しますHAS-Aあること。この関係は、バグだけでなくコードの重複を減らすのに役立ちます。
例を見てみましょう-
Example
public class Vehicle{}
public class Speed{}
public class Van extends Vehicle {
private Speed sp;
}
これは、クラスVan HAS-ASpeedを示しています。Speed用に個別のクラスを用意することで、speedに属するコード全体をVanクラス内に配置する必要がなくなり、複数のアプリケーションでSpeedクラスを再利用できるようになります。
オブジェクト指向機能では、ユーザーはどのオブジェクトが実際の作業を行っているかを気にする必要はありません。これを実現するために、VanクラスはVanクラスのユーザーから実装の詳細を隠します。したがって、基本的には、ユーザーはVanクラスに特定のアクションを実行するように要求し、Vanクラスはそれ自体で作業を実行するか、別のクラスにアクションを実行するように要求します。
継承の種類
以下に示すように、さまざまなタイプの継承があります。
覚えておくべき非常に重要な事実は、Javaは多重継承をサポートしていないということです。これは、クラスが複数のクラスを拡張できないことを意味します。したがって、以下は違法です-
Example
public class extends Animal, Mammal{}
ただし、クラスは1つ以上のインターフェースを実装できるため、Javaは多重継承の不可能性を取り除くことができます。
前の章では、スーパークラスとサブクラスについて説明しました。クラスがそのスーパークラスからメソッドを継承する場合、finalとマークされていなければ、メソッドをオーバーライドする可能性があります。
オーバーライドの利点は次のとおりです。サブクラスタイプに固有の動作を定義する機能。つまり、サブクラスはその要件に基づいて親クラスメソッドを実装できます。
オブジェクト指向の用語では、オーバーライドとは、既存のメソッドの機能をオーバーライドすることを意味します。
例
例を見てみましょう。
class Animal {
public void move() {
System.out.println("Animals can move");
}
}
class Dog extends Animal {
public void move() {
System.out.println("Dogs can walk and run");
}
}
public class TestDog {
public static void main(String args[]) {
Animal a = new Animal(); // Animal reference and object
Animal b = new Dog(); // Animal reference but Dog object
a.move(); // runs the method in Animal class
b.move(); // runs the method in Dog class
}
}
これにより、次の結果が生成されます-
出力
Animals can move
Dogs can walk and run
上記の例では、 bDogクラスのmoveメソッドを実行するAnimalの一種です。この理由は次のとおりです。コンパイル時に、参照型がチェックされます。ただし、ランタイムでは、JVMはオブジェクトタイプを把握し、その特定のオブジェクトに属するメソッドを実行します。
したがって、上記の例では、Animalクラスにメソッドmoveがあるため、プログラムは正しくコンパイルされます。次に、実行時に、そのオブジェクトに固有のメソッドを実行します。
次の例を考えてみましょう-
例
class Animal {
public void move() {
System.out.println("Animals can move");
}
}
class Dog extends Animal {
public void move() {
System.out.println("Dogs can walk and run");
}
public void bark() {
System.out.println("Dogs can bark");
}
}
public class TestDog {
public static void main(String args[]) {
Animal a = new Animal(); // Animal reference and object
Animal b = new Dog(); // Animal reference but Dog object
a.move(); // runs the method in Animal class
b.move(); // runs the method in Dog class
b.bark();
}
}
これにより、次の結果が生成されます-
出力
TestDog.java:26: error: cannot find symbol
b.bark();
^
symbol: method bark()
location: variable b of type Animal
1 error
bの参照型Animalには樹皮という名前のメソッドがないため、このプログラムはコンパイル時エラーをスローします。
メソッドのオーバーライドのルール
引数リストは、オーバーライドされたメソッドの引数リストとまったく同じである必要があります。
戻り値の型は、スーパークラスの元のオーバーライドされたメソッドで宣言された戻り値の型と同じか、サブタイプである必要があります。
アクセスレベルは、オーバーライドされたメソッドのアクセスレベルよりも制限することはできません。例:スーパークラスメソッドがパブリックとして宣言されている場合、サブクラスのオーバーライドメソッドをプライベートにすることも保護することもできません。
インスタンスメソッドは、サブクラスに継承されている場合にのみオーバーライドできます。
finalと宣言されたメソッドはオーバーライドできません。
staticと宣言されたメソッドはオーバーライドできませんが、再宣言できます。
メソッドを継承できない場合は、オーバーライドできません。
インスタンスのスーパークラスと同じパッケージ内のサブクラスは、privateまたはfinalとして宣言されていないスーパークラスメソッドをオーバーライドできます。
別のパッケージのサブクラスは、publicまたはprotectedと宣言された非finalメソッドのみをオーバーライドできます。
オーバーライドされたメソッドが例外をスローするかどうかに関係なく、オーバーライドするメソッドはチェック解除された例外をスローできます。ただし、オーバーライドするメソッドは、オーバーライドされたメソッドによって宣言されたものよりも新しい、またはより広いチェック済み例外をスローしないようにする必要があります。オーバーライドするメソッドは、オーバーライドされるメソッドよりも狭い、または少ない例外をスローできます。
コンストラクターはオーバーライドできません。
スーパーキーワードの使用
オーバーライドされたメソッドのスーパークラスバージョンを呼び出す場合、 super キーワードが使用されます。
例
class Animal {
public void move() {
System.out.println("Animals can move");
}
}
class Dog extends Animal {
public void move() {
super.move(); // invokes the super class method
System.out.println("Dogs can walk and run");
}
}
public class TestDog {
public static void main(String args[]) {
Animal b = new Dog(); // Animal reference but Dog object
b.move(); // runs the method in Dog class
}
}
これにより、次の結果が生成されます-
出力
Animals can move
Dogs can walk and run
ポリモーフィズムは、オブジェクトがさまざまな形をとる能力です。OOPでのポリモーフィズムの最も一般的な使用法は、親クラス参照を使用して子クラスオブジェクトを参照する場合に発生します。
複数のIS-Aテストに合格できるJavaオブジェクトは、ポリモーフィックであると見なされます。Javaでは、すべてのJavaオブジェクトは多形です。これは、どのオブジェクトも、独自のタイプとクラスObjectのIS-Aテストに合格するためです。
オブジェクトにアクセスする唯一の可能な方法は、参照変数を使用することであることを知っておくことが重要です。参照変数は1つのタイプのみにすることができます。宣言されると、参照変数のタイプは変更できません。
参照変数は、finalとして宣言されていない限り、他のオブジェクトに再割り当てできます。参照変数のタイプによって、オブジェクトで呼び出すことができるメソッドが決まります。
参照変数は、宣言された型の任意のオブジェクトまたは宣言された型の任意のサブタイプを参照できます。参照変数は、クラスまたはインターフェイスタイプとして宣言できます。
例
例を見てみましょう。
public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}
現在、Deerクラスは多重継承を持っているため、ポリモーフィックであると見なされます。上記の例については、次のことが当てはまります。
- 鹿IS-動物
- 鹿IS-菜食主義者
- 鹿IS-鹿
- 鹿IS-オブジェクト
参照変数factsをDeerオブジェクト参照に適用する場合、次の宣言は有効です。
例
Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;
すべての参照変数d、a、v、oは、ヒープ内の同じDeerオブジェクトを参照します。
仮想メソッド
このセクションでは、Javaでオーバーライドされたメソッドの動作により、クラスを設計するときにポリモーフィズムを利用する方法を示します。
子クラスがその親のメソッドをオーバーライドできるメソッドのオーバーライドについては、すでに説明しました。オーバーライドされたメソッドは基本的に親クラスに隠されており、子クラスがオーバーライドするメソッド内でsuperキーワードを使用しない限り呼び出されません。
例
/* File name : Employee.java */
public class Employee {
private String name;
private String address;
private int number;
public Employee(String name, String address, int number) {
System.out.println("Constructing an Employee");
this.name = name;
this.address = address;
this.number = number;
}
public void mailCheck() {
System.out.println("Mailing a check to " + this.name + " " + this.address);
}
public String toString() {
return name + " " + address + " " + number;
}
public String getName() {
return name;
}
public String getAddress() {
return address;
}
public void setAddress(String newAddress) {
address = newAddress;
}
public int getNumber() {
return number;
}
}
ここで、Employeeクラスを次のように拡張するとします。
/* File name : Salary.java */
public class Salary extends Employee {
private double salary; // Annual salary
public Salary(String name, String address, int number, double salary) {
super(name, address, number);
setSalary(salary);
}
public void mailCheck() {
System.out.println("Within mailCheck of Salary class ");
System.out.println("Mailing check to " + getName()
+ " with salary " + salary);
}
public double getSalary() {
return salary;
}
public void setSalary(double newSalary) {
if(newSalary >= 0.0) {
salary = newSalary;
}
}
public double computePay() {
System.out.println("Computing salary pay for " + getName());
return salary/52;
}
}
ここで、次のプログラムを注意深く調べて、その出力を決定しようとします-
/* File name : VirtualDemo.java */
public class VirtualDemo {
public static void main(String [] args) {
Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
System.out.println("Call mailCheck using Salary reference --");
s.mailCheck();
System.out.println("\n Call mailCheck using Employee reference--");
e.mailCheck();
}
}
これにより、次の結果が生成されます-
出力
Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0
Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.0
ここでは、2つのSalaryオブジェクトをインスタンス化します。給与参照を使用するものs、およびその他の従業員参照を使用 e。
s.mailCheck()を呼び出すと、コンパイラはコンパイル時にSalaryクラスのmailCheck()を認識し、JVMは実行時にSalaryクラスのmailCheck()を呼び出します。
mailCheck()on e まったく違うので e従業員の参照です。コンパイラがe.mailCheck()を確認すると、コンパイラはEmployeeクラスのmailCheck()メソッドを確認します。
ここで、コンパイル時に、コンパイラーはEmployeeでmailCheck()を使用してこのステートメントを検証しました。ただし、実行時に、JVMはSalaryクラスでmailCheck()を呼び出します。
この動作は仮想メソッド呼び出しと呼ばれ、これらのメソッドは仮想メソッドと呼ばれます。オーバーライドされたメソッドは、コンパイル時にソースコードで使用された参照のデータ型に関係なく、実行時に呼び出されます。
辞書によると、 abstractionイベントではなくアイデアを扱う品質です。たとえば、電子メールの場合、電子メールを送信するとすぐに何が起こるかなどの複雑な詳細を考えると、電子メールサーバーが使用するプロトコルはユーザーから隠されます。したがって、電子メールを送信するには、コンテンツを入力し、受信者のアドレスを指定して、[送信]をクリックするだけです。
同様に、オブジェクト指向プログラミングでは、抽象化は実装の詳細をユーザーから隠すプロセスであり、機能のみがユーザーに提供されます。つまり、ユーザーは、オブジェクトの実行方法ではなく、オブジェクトの実行内容に関する情報を取得できます。
Javaでは、抽象化は抽象クラスとインターフェースを使用して実現されます。
抽象クラス
を含むクラス abstract その宣言のキーワードは抽象クラスとして知られています。
抽象クラスには、抽象メソッド、つまり本体のないメソッドが含まれる場合と含まれない場合があります(public void get();)
ただし、クラスに少なくとも1つの抽象メソッドがある場合、そのクラスは must 抽象的であると宣言されます。
クラスが抽象として宣言されている場合、インスタンス化することはできません。
抽象クラスを使用するには、別のクラスから継承し、その中の抽象メソッドに実装を提供する必要があります。
抽象クラスを継承する場合は、その中のすべての抽象メソッドに実装を提供する必要があります。
例
このセクションでは、抽象クラスの例を示します。抽象クラスを作成するには、abstract クラス宣言のclassキーワードの前のkeyword。
/* File name : Employee.java */
public abstract class Employee {
private String name;
private String address;
private int number;
public Employee(String name, String address, int number) {
System.out.println("Constructing an Employee");
this.name = name;
this.address = address;
this.number = number;
}
public double computePay() {
System.out.println("Inside Employee computePay");
return 0.0;
}
public void mailCheck() {
System.out.println("Mailing a check to " + this.name + " " + this.address);
}
public String toString() {
return name + " " + address + " " + number;
}
public String getName() {
return name;
}
public String getAddress() {
return address;
}
public void setAddress(String newAddress) {
address = newAddress;
}
public int getNumber() {
return number;
}
}
抽象メソッドを除いて、EmployeeクラスはJavaの通常のクラスと同じであることがわかります。クラスは抽象化されましたが、3つのフィールド、7つのメソッド、および1つのコンストラクターがあります。
これで、次の方法でEmployeeクラスのインスタンス化を試みることができます-
/* File name : AbstractDemo.java */
public class AbstractDemo {
public static void main(String [] args) {
/* Following is not allowed and would raise error */
Employee e = new Employee("George W.", "Houston, TX", 43);
System.out.println("\n Call mailCheck using Employee reference--");
e.mailCheck();
}
}
上記のクラスをコンパイルすると、次のエラーが発生します-
Employee.java:46: Employee is abstract; cannot be instantiated
Employee e = new Employee("George W.", "Houston, TX", 43);
^
1 error
抽象クラスの継承
Employeeクラスのプロパティは、具象クラスと同じように次のように継承できます。
例
/* File name : Salary.java */
public class Salary extends Employee {
private double salary; // Annual salary
public Salary(String name, String address, int number, double salary) {
super(name, address, number);
setSalary(salary);
}
public void mailCheck() {
System.out.println("Within mailCheck of Salary class ");
System.out.println("Mailing check to " + getName() + " with salary " + salary);
}
public double getSalary() {
return salary;
}
public void setSalary(double newSalary) {
if(newSalary >= 0.0) {
salary = newSalary;
}
}
public double computePay() {
System.out.println("Computing salary pay for " + getName());
return salary/52;
}
}
ここでは、Employeeクラスをインスタンス化することはできませんが、Salaryクラスをインスタンス化することはできます。このインスタンスを使用すると、以下に示すように、Employeeクラスの3つのフィールドすべてと7つのメソッドにアクセスできます。
/* File name : AbstractDemo.java */
public class AbstractDemo {
public static void main(String [] args) {
Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
System.out.println("Call mailCheck using Salary reference --");
s.mailCheck();
System.out.println("\n Call mailCheck using Employee reference--");
e.mailCheck();
}
}
これにより、次の結果が生成されます-
出力
Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0
Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.0
抽象メソッド
クラスに特定のメソッドを含めたいが、そのメソッドの実際の実装を子クラスによって決定したい場合は、親クラスのメソッドを抽象として宣言できます。
abstract キーワードは、メソッドを抽象として宣言するために使用されます。
あなたは配置する必要があります abstract メソッド宣言のメソッド名の前のキーワード。
抽象メソッドにはメソッドシグネチャが含まれていますが、メソッド本体は含まれていません。
中括弧の代わりに、抽象メソッドの最後にセモイコロン(;)があります。
以下は、抽象メソッドの例です。
例
public abstract class Employee {
private String name;
private String address;
private int number;
public abstract double computePay();
// Remainder of class definition
}
メソッドを抽象として宣言すると、2つの結果が生じます-
それを含むクラスは、抽象として宣言する必要があります。
現在のクラスを継承するクラスは、abstractメソッドをオーバーライドするか、それ自体を抽象として宣言する必要があります。
Note−最終的に、子孫クラスは抽象メソッドを実装する必要があります。そうしないと、インスタンス化できない抽象クラスの階層ができてしまいます。
SalaryクラスがEmployeeクラスを継承するとし、実装する必要があります computePay() 以下に示す方法-
/* File name : Salary.java */
public class Salary extends Employee {
private double salary; // Annual salary
public double computePay() {
System.out.println("Computing salary pay for " + getName());
return salary/52;
}
// Remainder of class definition
}
Encapsulationは、4つの基本的なOOP概念の1つです。他の3つは、継承、ポリモーフィズム、および抽象化です。
Javaでのカプセル化は、データ(変数)とデータに作用するコード(メソッド)を1つのユニットとしてまとめるメカニズムです。カプセル化では、クラスの変数は他のクラスから隠され、現在のクラスのメソッドを介してのみアクセスできます。したがって、それはまた知られていますdata hiding。
Javaでカプセル化を実現するには-
クラスの変数をプライベートとして宣言します。
変数値を変更および表示するためのパブリックsetterおよびgetterメソッドを提供します。
例
以下は、Javaでカプセル化を実現する方法を示す例です。
/* File name : EncapTest.java */
public class EncapTest {
private String name;
private String idNum;
private int age;
public int getAge() {
return age;
}
public String getName() {
return name;
}
public String getIdNum() {
return idNum;
}
public void setAge( int newAge) {
age = newAge;
}
public void setName(String newName) {
name = newName;
}
public void setIdNum( String newId) {
idNum = newId;
}
}
パブリックsetXXX()およびgetXXX()メソッドは、EncapTestクラスのインスタンス変数のアクセスポイントです。通常、これらのメソッドはゲッターおよびセッターと呼ばれます。したがって、変数にアクセスしたいクラスは、これらのゲッターとセッターを介して変数にアクセスする必要があります。
EncapTestクラスの変数には、次のプログラムを使用してアクセスできます。
/* File name : RunEncap.java */
public class RunEncap {
public static void main(String args[]) {
EncapTest encap = new EncapTest();
encap.setName("James");
encap.setAge(20);
encap.setIdNum("12343ms");
System.out.print("Name : " + encap.getName() + " Age : " + encap.getAge());
}
}
これにより、次の結果が生成されます-
出力
Name : James Age : 20
カプセル化の利点
クラスのフィールドは、読み取り専用または書き込み専用にすることができます。
クラスは、そのフィールドに格納される内容を完全に制御できます。
インターフェイスはJavaの参照型です。クラスに似ています。これは、抽象的なメソッドのコレクションです。クラスはインターフェースを実装し、それによってインターフェースの抽象メソッドを継承します。
インターフェイスには、抽象メソッドに加えて、定数、デフォルトメソッド、静的メソッド、およびネストされた型も含まれる場合があります。メソッド本体は、デフォルトのメソッドと静的メソッドにのみ存在します。
インターフェイスの作成は、クラスの作成に似ています。ただし、クラスはオブジェクトの属性と動作を記述します。また、インターフェイスには、クラスが実装する動作が含まれています。
インターフェイスを実装するクラスが抽象でない限り、インターフェイスのすべてのメソッドをクラスで定義する必要があります。
インターフェイスは、次の点でクラスに似ています-
インターフェイスには、任意の数のメソッドを含めることができます。
インターフェイスは、ファイルに書き込まれます。 .java ファイルの名前と一致するインターフェースの名前を持つ拡張子。
インターフェイスのバイトコードは、 .class ファイル。
インターフェイスはパッケージに表示され、対応するバイトコードファイルはパッケージ名と一致するディレクトリ構造である必要があります。
ただし、インターフェイスは、次のようないくつかの点でクラスとは異なります。
インターフェイスをインスタンス化することはできません。
インターフェイスにはコンストラクタが含まれていません。
インターフェイスのすべてのメソッドは抽象的です。
インターフェイスにインスタンスフィールドを含めることはできません。インターフェイスに表示できる唯一のフィールドは、静的と最終の両方で宣言する必要があります。
インターフェイスはクラスによって拡張されません。クラスによって実装されます。
インターフェイスは複数のインターフェイスを拡張できます。
インターフェイスの宣言
ザ・ interfaceキーワードは、インターフェイスを宣言するために使用されます。これはインターフェースを宣言する簡単な例です-
例
以下はインターフェースの例です-
/* File name : NameOfInterface.java */
import java.lang.*;
// Any number of import statements
public interface NameOfInterface {
// Any number of final, static fields
// Any number of abstract method declarations\
}
インターフェイスには次のプロパティがあります-
インターフェイスは暗黙的に抽象的です。を使用する必要はありませんabstract インターフェイスを宣言する際のキーワード。
インターフェイスの各メソッドも暗黙的に抽象化されているため、abstractキーワードは必要ありません。
インターフェイスのメソッドは暗黙的にパブリックです。
例
/* File name : Animal.java */
interface Animal {
public void eat();
public void travel();
}
インターフェースの実装
クラスがインターフェースを実装する場合、クラスはコントラクトに署名し、インターフェースの特定の動作を実行することに同意するものと考えることができます。クラスがインターフェイスのすべての動作を実行しない場合、クラスはそれ自体を抽象として宣言する必要があります。
クラスは implementsインターフェイスを実装するためのキーワード。implementsキーワードは、宣言のextends部分に続くクラス宣言に表示されます。
例
/* File name : MammalInt.java */
public class MammalInt implements Animal {
public void eat() {
System.out.println("Mammal eats");
}
public void travel() {
System.out.println("Mammal travels");
}
public int noOfLegs() {
return 0;
}
public static void main(String args[]) {
MammalInt m = new MammalInt();
m.eat();
m.travel();
}
}
これにより、次の結果が生成されます-
出力
Mammal eats
Mammal travels
インターフェイスで定義されたメソッドをオーバーライドする場合、従うべきいくつかのルールがあります-
チェックされた例外は、インターフェイスメソッドによって宣言されたものまたはインターフェイスメソッドによって宣言されたサブクラス以外の実装メソッドで宣言しないでください。
メソッドをオーバーライドするときは、インターフェイスメソッドのシグネチャと同じ戻り値の型またはサブタイプを維持する必要があります。
実装クラス自体は抽象的である可能性があり、その場合、インターフェースメソッドを実装する必要はありません。
実装インターフェースの場合、いくつかのルールがあります-
クラスは、一度に複数のインターフェースを実装できます。
クラスは1つのクラスのみを拡張できますが、多くのインターフェースを実装します。
クラスが別のクラスを拡張できるのと同様の方法で、インターフェイスは別のインターフェイスを拡張できます。
インターフェイスの拡張
インターフェイスは、クラスが別のクラスを拡張できるのと同じ方法で、別のインターフェイスを拡張できます。ザ・extends キーワードはインターフェイスを拡張するために使用され、子インターフェイスは親インターフェイスのメソッドを継承します。
次のスポーツインターフェースは、ホッケーとサッカーのインターフェースによって拡張されています。
例
// Filename: Sports.java
public interface Sports {
public void setHomeTeam(String name);
public void setVisitingTeam(String name);
}
// Filename: Football.java
public interface Football extends Sports {
public void homeTeamScored(int points);
public void visitingTeamScored(int points);
public void endOfQuarter(int quarter);
}
// Filename: Hockey.java
public interface Hockey extends Sports {
public void homeGoalScored();
public void visitingGoalScored();
public void endOfPeriod(int period);
public void overtimePeriod(int ot);
}
Hockeyインターフェースには4つのメソッドがありますが、Sportsから2つを継承しています。したがって、Hockeyを実装するクラスは、6つのメソッドすべてを実装する必要があります。同様に、Footballを実装するクラスは、Footballの3つのメソッドとSportsの2つのメソッドを定義する必要があります。
複数のインターフェースの拡張
Javaクラスは、1つの親クラスのみを拡張できます。多重継承は許可されていません。ただし、インターフェイスはクラスではなく、インターフェイスは複数の親インターフェイスを拡張できます。
extendsキーワードは1回使用され、親インターフェイスはコンマ区切りのリストで宣言されます。
たとえば、ホッケーのインターフェースがスポーツとイベントの両方を拡張した場合、次のように宣言されます。
例
public interface Hockey extends Sports, Event
タグ付けインターフェース
拡張インターフェースの最も一般的な使用法は、親インターフェースにメソッドが含まれていない場合に発生します。たとえば、java.awt.eventパッケージのMouseListenerインターフェースは、-として定義されているjava.util.EventListenerを拡張しました。
例
package java.util;
public interface EventListener
{}
メソッドが含まれていないインターフェースは、 taggingインターフェース。インターフェイスのタグ付けには、2つの基本的な設計目的があります-
Creates a common parent− Java APIの他の数十のインターフェースによって拡張されるEventListenerインターフェースと同様に、タグ付けインターフェースを使用して、インターフェースのグループ間で共通の親を作成できます。たとえば、インターフェースがEventListenerを拡張する場合、JVMは、この特定のインターフェースがイベント委任シナリオで使用されることを認識しています。
Adds a data type to a class−この状況は、タグ付けという用語の由来です。タグ付けインターフェイスを実装するクラスは、メソッドを定義する必要はありませんが(インターフェイスにはメソッドがないため)、クラスはポリモーフィズムによってインターフェイスタイプになります。
パッケージは、名前の競合を防ぎ、アクセスを制御し、クラス、インターフェイス、列挙、および注釈の検索/検索と使用を容易にするために、Javaで使用されます。
A Package アクセス保護と名前空間管理を提供する関連タイプ(クラス、インターフェース、列挙、および注釈)のグループとして定義できます。
Javaの既存のパッケージのいくつかは次のとおりです。
java.lang −基本クラスをバンドルします
java.io −入力、出力関数のクラスがこのパッケージにバンドルされています
プログラマーは独自のパッケージを定義して、クラス/インターフェースなどのグループをバンドルできます。プログラマーがクラス、インターフェース、列挙、および注釈が関連していることを簡単に判断できるように、実装した関連クラスをグループ化することをお勧めします。
パッケージは新しい名前空間を作成するため、他のパッケージの名前と名前が競合することはありません。パッケージを使用すると、アクセス制御を提供しやすくなり、関連するクラスを見つけることも簡単になります。
パッケージの作成
パッケージを作成するときに、パッケージの名前を選択し、 package パッケージに含めるクラス、インターフェイス、列挙型、および注釈タイプを含むすべてのソースファイルの上部にあるその名前とともにステートメント。
パッケージステートメントは、ソースファイルの最初の行である必要があります。各ソースファイルには1つのパッケージステートメントしか存在できず、ファイル内のすべてのタイプに適用されます。
パッケージステートメントが使用されていない場合、クラス、インターフェイス、列挙、および注釈タイプは、現在のデフォルトパッケージに配置されます。
パッケージステートメントを使用してJavaプログラムをコンパイルするには、以下に示すように-dオプションを使用する必要があります。
javac -d Destination_folder file_name.java
次に、指定されたパッケージ名のフォルダーが指定された宛先に作成され、コンパイルされたクラスファイルがそのフォルダーに配置されます。
例
というパッケージを作成する例を見てみましょう。 animals。クラスやインターフェイスの名前との競合を避けるために、小文字のパッケージ名を使用することをお勧めします。
次のパッケージ例には、animalsという名前のインターフェイスが含まれています-
/* File name : Animal.java */
package animals;
interface Animal {
public void eat();
public void travel();
}
さて、同じパッケージ動物に上記のインターフェースを実装しましょう-
package animals;
/* File name : MammalInt.java */
public class MammalInt implements Animal {
public void eat() {
System.out.println("Mammal eats");
}
public void travel() {
System.out.println("Mammal travels");
}
public int noOfLegs() {
return 0;
}
public static void main(String args[]) {
MammalInt m = new MammalInt();
m.eat();
m.travel();
}
}
次に、以下に示すようにJavaファイルをコンパイルします-
$ javac -d . Animal.java $ javac -d . MammalInt.java
今、名前のパッケージ/フォルダ animals は現在のディレクトリに作成され、これらのクラスファイルは次のように配置されます。
パッケージ内でクラスファイルを実行すると、次のような結果が得られます。
Mammal eats
Mammal travels
インポートキーワード
クラスが同じパッケージ内の別のクラスを使用する場合は、パッケージ名を使用する必要はありません。同じパッケージ内のクラスは、特別な構文なしでお互いを見つけます。
例
ここでは、すでにEmployeeが含まれている給与パッケージにBossという名前のクラスが追加されています。次のBossクラスで示されているように、Bossは、給与プレフィックスを使用せずにEmployeeクラスを参照できます。
package payroll;
public class Boss {
public void payEmployee(Employee e) {
e.mailCheck();
}
}
Employeeクラスが給与パッケージに含まれていない場合はどうなりますか?次に、Bossクラスは、別のパッケージ内のクラスを参照するために、次のいずれかの手法を使用する必要があります。
- クラスの完全修飾名を使用できます。例-
payroll.Employee
パッケージは、importキーワードとワイルドカード(*)を使用してインポートできます。例-
import payroll.*;
- クラス自体は、importキーワードを使用してインポートできます。例-
import payroll.Employee;
Note−クラスファイルには、任意の数のインポートステートメントを含めることができます。importステートメントは、packageステートメントの後、class宣言の前に表示する必要があります。
パッケージのディレクトリ構造
クラスがパッケージに配置されると、2つの主要な結果が発生します-
前のセクションで説明したように、パッケージの名前はクラスの名前の一部になります。
パッケージの名前は、対応するバイトコードが存在するディレクトリ構造と一致する必要があります。
Javaでファイルを管理する簡単な方法は次のとおりです-
クラス、インターフェイス、列挙型、または注釈タイプのソースコードを、名前がタイプの単純な名前で、拡張子が .java。
例-
// File Name : Car.java
package vehicle;
public class Car {
// Class implementation.
}
ここで、クラスが属するパッケージの名前を反映した名前のディレクトリにソースファイルを配置します-
....\vehicle\Car.java
これで、修飾されたクラス名とパス名は次のようになります。
- クラス名→車両。車
- パス名→vehicle \ Car.java(Windows内)
一般に、会社はパッケージ名に逆のインターネットドメイン名を使用します。
Example−会社のインターネットドメイン名がapple.comの場合、すべてのパッケージ名はcom.appleで始まります。パッケージ名の各コンポーネントは、サブディレクトリに対応しています。
Example −会社にはDell.javaソースファイルを含むcom.apple.computersパッケージがあり、このような一連のサブディレクトリに含まれていました−
....\com\apple\computers\Dell.java
コンパイル時に、コンパイラーは、クラス、インターフェース、および列挙型で定義されているものごとに異なる出力ファイルを作成します。出力ファイルのベース名はタイプの名前であり、その拡張子は.class。
例-
// File Name: Dell.java
package com.apple.computers;
public class Dell {
}
class Ups {
}
ここで、-dオプション-を使用して、このファイルを次のようにコンパイルします。
$javac -d . Dell.java
ファイルは次のようにコンパイルされます-
.\com\apple\computers\Dell.class
.\com\apple\computers\Ups.class
次のように、\ com \ apple \ computers \で定義されているすべてのクラスまたはインターフェイスをインポートできます。
import com.apple.computers.*;
.javaソースファイルと同様に、コンパイルされた.classファイルは、パッケージ名を反映する一連のディレクトリにある必要があります。ただし、.classファイルへのパスは、.javaソースファイルへのパスと同じである必要はありません。次のように、ソースディレクトリとクラスディレクトリを別々に配置できます。
<path-one>\sources\com\apple\computers\Dell.java
<path-two>\classes\com\apple\computers\Dell.class
これを行うことにより、ソースを明らかにすることなく、他のプログラマーにクラスディレクトリへのアクセスを与えることができます。また、コンパイラとJava仮想マシン(JVM)がプログラムで使用するすべてのタイプを検出できるように、この方法でソースファイルとクラスファイルを管理する必要があります。
クラスディレクトリへのフルパス<path-two> \ classesは、クラスパスと呼ばれ、CLASSPATHシステム変数で設定されます。コンパイラとJVMの両方が、パッケージ名をクラスパスに追加することにより、.classファイルへのパスを構築します。
<path-two> \ classesがクラスパスで、パッケージ名がcom.apple.computersの場合、コンパイラとJVMは<path-two> \ classes \ com \ apple \ computersで.classファイルを検索します。
クラスパスには、複数のパスが含まれる場合があります。複数のパスは、セミコロン(Windows)またはコロン(Unix)で区切る必要があります。デフォルトでは、コンパイラとJVMは、現在のディレクトリとJavaプラットフォームクラスを含むJARファイルを検索して、これらのディレクトリが自動的にクラスパスに含まれるようにします。
CLASSPATHシステム変数を設定する
現在のCLASSPATH変数を表示するには、WindowsおよびUNIX(Bourneシェル)で次のコマンドを使用します-
- Windowsの場合→C:\> CLASSPATHを設定します
- UNIXの場合→%echo $ CLASSPATH
CLASSPATH変数の現在の内容を削除するには、-を使用します。
- Windows→C:\> set CLASSPATH =
- UNIXの場合→%unset CLASSPATH; CLASSPATHをエクスポートします
CLASSPATH変数を設定するには-
- Windowsの場合→CLASSPATH = C:\ users \ jack \ java \ classesを設定します
- UNIXの場合→%CLASSPATH = / home / jack / java / classes; CLASSPATHをエクスポートします
Javaユーティリティパッケージによって提供されるデータ構造は非常に強力で、さまざまな機能を実行します。これらのデータ構造は、次のインターフェイスとクラスで構成されています-
- Enumeration
- BitSet
- Vector
- Stack
- Dictionary
- Hashtable
- Properties
これらのクラスはすべてレガシーであり、Java-2はCollectionsFrameworkと呼ばれる新しいフレームワークを導入しました。これについては次の章で説明します。−
列挙
列挙型インターフェース自体はデータ構造ではありませんが、他のデータ構造のコンテキスト内では非常に重要です。列挙型インターフェースは、データ構造から連続する要素を取得する手段を定義します。
たとえば、Enumerationは、複数の要素を含むデータ構造内の次の要素を取得するために使用されるnextElementというメソッドを定義します。
このインターフェイスの詳細については、列挙を確認してください。
ビットセット
BitSetクラスは、個別に設定およびクリアできるビットまたはフラグのグループを実装します。
このクラスは、ブール値のセットについていく必要がある場合に非常に役立ちます。各値にビットを割り当て、必要に応じて設定またはクリアするだけです。
このクラスの詳細については、ビットセットを確認してください。
ベクトル
Vectorクラスは、新しい要素に対応するために必要に応じて拡張できることを除いて、従来のJava配列に似ています。
配列と同様に、Vectorオブジェクトの要素には、ベクターへのインデックスを介してアクセスできます。
Vectorクラスを使用することの良い点は、作成時に特定のサイズに設定することを心配する必要がないことです。必要に応じて自動的に縮小および拡大します。
このクラスの詳細については、チェックベクトルを。
スタック
Stackクラスは、後入れ先出し(LIFO)要素のスタックを実装します。
スタックは、文字通りオブジェクトの垂直スタックと考えることができます。新しい要素を追加すると、他の要素の上に積み重ねられます。
スタックから要素を引き出すと、その要素は一番上から外れます。つまり、スタックに最後に追加した要素が、最初に戻ってきた要素です。
このクラスの詳細については、スタックを確認してください。
辞書
Dictionaryクラスは、キーを値にマッピングするためのデータ構造を定義する抽象クラスです。
これは、整数インデックスではなく特定のキーを介してデータにアクセスできるようにする場合に役立ちます。
Dictionaryクラスは抽象的であるため、特定の実装ではなく、キーマップされたデータ構造のフレームワークのみを提供します。
このクラスの詳細については、辞書を確認してください。
ハッシュテーブル
Hashtableクラスは、ユーザー定義のキー構造に基づいてデータを整理する手段を提供します。
たとえば、住所リストのハッシュテーブルでは、人の名前ではなく、郵便番号などのキーに基づいてデータを保存および並べ替えることができます。
ハッシュテーブルに関するキーの具体的な意味は、ハッシュテーブルの使用法とそれに含まれるデータに完全に依存します。
このクラスの詳細については、TheHashtableを確認してください。
プロパティ
プロパティはHashtableのサブクラスです。これは、キーが文字列であり、値も文字列である値のリストを維持するために使用されます。
Propertiesクラスは、他の多くのJavaクラスで使用されます。たとえば、環境値を取得するときにSystem.getProperties()によって返されるオブジェクトのタイプです。
このクラスの詳細については、[プロパティ]を確認してください。
Java 2より前は、Javaは次のようなアドホッククラスを提供していました。 Dictionary, Vector, Stack, そして Propertiesオブジェクトのグループを保存および操作します。これらのクラスは非常に便利でしたが、中心的で統一されたテーマがありませんでした。したがって、Vectorの使用方法は、Propertiesの使用方法とは異なります。
コレクションフレームワークは、次のようないくつかの目標を達成するように設計されています。
フレームワークは高性能でなければなりませんでした。基本的なコレクション(動的配列、リンクリスト、ツリー、およびハッシュテーブル)の実装は、非常に効率的である必要がありました。
フレームワークでは、さまざまなタイプのコレクションが同様の方法で、高度な相互運用性で機能できるようにする必要がありました。
フレームワークは、コレクションを簡単に拡張および/または適応させる必要がありました。
この目的に向けて、コレクションフレームワーク全体は、一連の標準インターフェイスを中心に設計されています。次のようないくつかの標準的な実装LinkedList, HashSet, そして TreeSet、これらのインターフェイスのうち、そのまま使用できるものが提供されており、必要に応じて独自のコレクションを実装することもできます。
コレクションフレームワークは、コレクションを表現および操作するための統合アーキテクチャです。すべてのコレクションフレームワークには、次のものが含まれています。
Interfaces−これらはコレクションを表す抽象データ型です。インターフェイスを使用すると、コレクションを表現の詳細とは関係なく操作できます。オブジェクト指向言語では、インターフェイスは一般に階層を形成します。
Implementations, i.e., Classes−これらはコレクションインターフェイスの具体的な実装です。本質的に、それらは再利用可能なデータ構造です。
Algorithms−これらは、コレクションインターフェイスを実装するオブジェクトに対して、検索や並べ替えなどの便利な計算を実行するメソッドです。アルゴリズムはポリモーフィックであると言われています。つまり、適切なコレクションインターフェイスのさまざまな実装で同じメソッドを使用できます。
コレクションに加えて、フレームワークはいくつかのマップインターフェイスとクラスを定義します。マップはキーと値のペアを格納します。マップは、この用語を適切に使用するためのコレクションではありませんが、コレクションと完全に統合されています。
コレクションインターフェイス
コレクションフレームワークは、いくつかのインターフェイスを定義します。このセクションでは、各インターフェイスの概要を説明します-
シニア番号 | インターフェースと説明 |
---|---|
1 | コレクションインターフェイス これにより、オブジェクトのグループを操作できます。コレクション階層の最上位にあります。 |
2 | リストインターフェイス これは拡張します Collection Listのインスタンスは、要素の順序付けられたコレクションを格納します。 |
3 | セット これにより、コレクションが拡張され、一意の要素を含む必要があるセットが処理されます。 |
4 | SortedSet これにより、Setが拡張され、ソートされたセットが処理されます。 |
5 | 地図 これにより、一意のキーが値にマップされます。 |
6 | Map.Entry これは、マップ内の要素(キーと値のペア)を記述します。これはMapの内部クラスです。 |
7 | SortedMap これによりMapが拡張され、キーが昇順で維持されます。 |
8 | 列挙 これはレガシーインターフェイスであり、オブジェクトのコレクション内の要素を列挙(一度に1つずつ取得)できるメソッドを定義します。このレガシーインターフェイスは、Iteratorに取って代わられました。 |
コレクションクラス
Javaは、コレクションインターフェイスを実装する一連の標準コレクションクラスを提供します。一部のクラスは、そのまま使用できる完全な実装を提供し、その他のクラスは抽象クラスであり、具体的なコレクションを作成するための開始点として使用される骨格の実装を提供します。
標準のコレクションクラスは、次の表にまとめられています。
シニア番号 | クラスと説明 |
---|---|
1 | AbstractCollection コレクションインターフェイスのほとんどを実装します。 |
2 | AbstractList AbstractCollectionを拡張し、ほとんどのListインターフェイスを実装します。 |
3 | AbstractSequentialList 要素のランダムアクセスではなくシーケンシャルアクセスを使用するコレクションで使用するためにAbstractListを拡張します。 |
4 | LinkedList AbstractSequentialListを拡張して、リンクリストを実装します。 |
5 | 配列リスト AbstractListを拡張して動的配列を実装します。 |
6 | AbstractSet AbstractCollectionを拡張し、Setインターフェイスのほとんどを実装します。 |
7 | HashSet ハッシュテーブルで使用するためにAbstractSetを拡張します。 |
8 | LinkedHashSet HashSetを拡張して、挿入順序の反復を可能にします。 |
9 | TreeSet ツリーに格納されたセットを実装します。AbstractSetを拡張します。 |
10 | AbstractMap ほとんどのマップインターフェイスを実装します。 |
11 | HashMap ハッシュテーブルを使用するようにAbstractMapを拡張します。 |
12 | TreeMap ツリーを使用するようにAbstractMapを拡張します。 |
13 | WeakHashMap AbstractMapを拡張して、弱いキーを持つハッシュテーブルを使用します。 |
14 | LinkedHashMap HashMapを拡張して、挿入順序の反復を可能にします。 |
15 | IdentityHashMap AbstractMapを拡張し、ドキュメントを比較するときに参照の同等性を使用します。 |
AbstractCollectionは、AbstractSet、AbstractList、AbstractSequentialListとAbstractMapのクラスがそれを実装するために必要な労力を最小限に抑えるために、コアコレクションインタフェースのスケルトン実装を提供します。
java.utilによって定義された次のレガシークラスについては、前の章で説明しました。
シニア番号 | クラスと説明 |
---|---|
1 | ベクター これにより、動的配列が実装されます。ArrayListに似ていますが、いくつかの違いがあります。 |
2 | スタック スタックは、標準の後入れ先出しスタックを実装するVectorのサブクラスです。 |
3 | 辞書 ディクショナリは、キー/値ストレージリポジトリを表す抽象クラスであり、Mapのように動作します。 |
4 | ハッシュ表 ハッシュテーブルは元のjava.utilの一部であり、辞書の具体的な実装です。 |
5 | プロパティ プロパティはHashtableのサブクラスです。これは、キーが文字列であり、値も文字列である値のリストを維持するために使用されます。 |
6 | BitSet BitSetクラスは、ビット値を保持する特別なタイプの配列を作成します。この配列は、必要に応じてサイズを増やすことができます。 |
収集アルゴリズム
コレクションフレームワークは、コレクションとマップに適用できるいくつかのアルゴリズムを定義します。これらのアルゴリズムは、Collectionsクラス内の静的メソッドとして定義されています。
いくつかの方法で ClassCastException、互換性のないタイプを比較しようとしたときに発生します。 UnsupportedOperationException、変更できないコレクションを変更しようとしたときに発生します。
コレクションは、EMPTY_SET、EMPTY_LIST、およびEMPTY_MAPの3つの静的変数を定義します。すべて不変です。
シニア番号 | アルゴリズムと説明 |
---|---|
1 | 収集アルゴリズム これは、すべてのアルゴリズム実装のリストです。 |
イテレータの使い方は?
多くの場合、コレクション内の要素を循環させたいと思うでしょう。たとえば、各要素を表示したい場合があります。
これを行う最も簡単な方法は、イテレータまたはListIteratorインターフェイスのいずれかを実装するオブジェクトであるイテレータを使用することです。
イテレータを使用すると、コレクションを循環して、要素を取得または削除できます。ListIteratorはIteratorを拡張して、リストの双方向トラバーサルと要素の変更を可能にします。
シニア番号 | イテレータの方法と説明 |
---|---|
1 | Javaイテレータの使用 これは、IteratorおよびListIteratorインターフェースによって提供される例を含むすべてのメソッドのリストです。 |
コンパレータの使い方は?
TreeSetとTreeMapはどちらも、要素を並べ替えられた順序で格納します。ただし、ソートされた順序の意味を正確に定義するのはコンパレータです。
このインターフェイスを使用すると、特定のコレクションをさまざまな方法で並べ替えることができます。また、このインターフェイスを使用して、任意のクラスの任意のインスタンスを並べ替えることができます(変更できないクラスも)。
シニア番号 | イテレータの方法と説明 |
---|---|
1 | Javaコンパレータの使用 これは、ComparatorInterfaceによって提供される例を含むすべてのメソッドのリストです。 |
概要
Javaコレクションフレームワークにより、プログラマは事前にパッケージ化されたデータ構造と、それらを操作するためのアルゴリズムにアクセスできます。
コレクションは、他のオブジェクトへの参照を保持できるオブジェクトです。コレクションインターフェイスは、各タイプのコレクションで実行できる操作を宣言します。
コレクションフレームワークのクラスとインターフェイスは、パッケージjava.utilにあります。
整数配列、文字列配列、または順序付けをサポートする任意の型の配列の要素を並べ替えることができる単一の並べ替えメソッドを作成できれば便利です。
Java Generic メソッドとジェネリッククラスを使用すると、プログラマーは、単一のメソッド宣言で関連するメソッドのセットを指定するか、単一のクラス宣言で関連するタイプのセットをそれぞれ指定できます。
ジェネリックスは、プログラマーがコンパイル時に無効な型をキャッチできるようにするコンパイル時の型安全性も提供します。
Java Genericの概念を使用して、オブジェクトの配列を並べ替えるための汎用メソッドを記述し、次に整数配列、二重配列、文字列配列などを使用して汎用メソッドを呼び出し、配列要素を並べ替えることができます。
一般的な方法
さまざまなタイプの引数を使用して呼び出すことができる単一のジェネリックメソッド宣言を記述できます。ジェネリックメソッドに渡される引数のタイプに基づいて、コンパイラは各メソッド呼び出しを適切に処理します。一般的なメソッドを定義するためのルールは次のとおりです-
すべてのジェネリックメソッド宣言には、メソッドの戻り値の型(次の例では<E>)の前に山括弧(<および>)で区切られた型パラメーターセクションがあります。
各型パラメーターセクションには、コンマで区切られた1つ以上の型パラメーターが含まれます。型変数とも呼ばれる型パラメーターは、ジェネリック型名を指定する識別子です。
型パラメーターを使用して、戻り値の型を宣言し、実際の型引数と呼ばれる、汎用メソッドに渡される引数の型のプレースホルダーとして機能できます。
ジェネリックメソッドの本体は、他のメソッドと同じように宣言されます。型パラメーターは、プリミティブ型(int、double、charなど)ではなく、参照型のみを表すことができることに注意してください。
例
次の例は、単一のジェネリックメソッドを使用して異なるタイプの配列を出力する方法を示しています。
public class GenericMethodTest {
// generic method printArray
public static < E > void printArray( E[] inputArray ) {
// Display array elements
for(E element : inputArray) {
System.out.printf("%s ", element);
}
System.out.println();
}
public static void main(String args[]) {
// Create arrays of Integer, Double and Character
Integer[] intArray = { 1, 2, 3, 4, 5 };
Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
System.out.println("Array integerArray contains:");
printArray(intArray); // pass an Integer array
System.out.println("\nArray doubleArray contains:");
printArray(doubleArray); // pass a Double array
System.out.println("\nArray characterArray contains:");
printArray(charArray); // pass a Character array
}
}
これにより、次の結果が生成されます-
出力
Array integerArray contains:
1 2 3 4 5
Array doubleArray contains:
1.1 2.2 3.3 4.4
Array characterArray contains:
H E L L O
有界型パラメーター
タイプパラメータに渡すことができるタイプの種類を制限したい場合があります。たとえば、数値を操作するメソッドは、数値またはそのサブクラスのインスタンスのみを受け入れたい場合があります。これが、有界型パラメーターの目的です。
有界型パラメーターを宣言するには、型パラメーターの名前、extendsキーワード、およびその上限をリストします。
例
次の例は、extendsが一般的な意味でどのように使用されているかを示しています。この例は、3つの比較可能なオブジェクトの最大のものを返すジェネリックメソッドです-
public class MaximumTest {
// determines the largest of three Comparable objects
public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
T max = x; // assume x is initially the largest
if(y.compareTo(max) > 0) {
max = y; // y is the largest so far
}
if(z.compareTo(max) > 0) {
max = z; // z is the largest now
}
return max; // returns the largest object
}
public static void main(String args[]) {
System.out.printf("Max of %d, %d and %d is %d\n\n",
3, 4, 5, maximum( 3, 4, 5 ));
System.out.printf("Max of %.1f,%.1f and %.1f is %.1f\n\n",
6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ));
System.out.printf("Max of %s, %s and %s is %s\n","pear",
"apple", "orange", maximum("pear", "apple", "orange"));
}
}
これにより、次の結果が生成されます-
出力
Max of 3, 4 and 5 is 5
Max of 6.6,8.8 and 7.7 is 8.8
Max of pear, apple and orange is pear
ジェネリッククラス
ジェネリッククラス宣言は、クラス名の後に型パラメーターセクションが続くことを除いて、非ジェネリッククラス宣言のように見えます。
ジェネリックメソッドと同様に、ジェネリッククラスの型パラメーターセクションには、コンマで区切った1つ以上の型パラメーターを含めることができます。これらのクラスは、1つ以上のパラメーターを受け入れるため、パラメーター化クラスまたはパラメーター化タイプと呼ばれます。
例
次の例は、ジェネリッククラスを定義する方法を示しています-
public class Box<T> {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
Box<String> stringBox = new Box<String>();
integerBox.add(new Integer(10));
stringBox.add(new String("Hello World"));
System.out.printf("Integer Value :%d\n\n", integerBox.get());
System.out.printf("String Value :%s\n", stringBox.get());
}
}
これにより、次の結果が生成されます-
出力
Integer Value :10
String Value :Hello World
Javaは、オブジェクトのシリアル化と呼ばれるメカニズムを提供します。このメカニズムでは、オブジェクトのデータ、オブジェクトのタイプ、およびオブジェクトに格納されているデータのタイプに関する情報を含むバイトのシーケンスとしてオブジェクトを表すことができます。
シリアル化されたオブジェクトがファイルに書き込まれた後、ファイルから読み取って逆シリアル化できます。つまり、オブジェクトとそのデータを表すタイプ情報とバイトを使用して、メモリ内にオブジェクトを再作成できます。
最も印象的なのは、プロセス全体がJVMに依存しないことです。つまり、オブジェクトを1つのプラットフォームでシリアル化し、まったく異なるプラットフォームで逆シリアル化できます。
クラス ObjectInputStream そして ObjectOutputStream オブジェクトをシリアル化および逆シリアル化するためのメソッドを含む高レベルのストリームです。
ObjectOutputStreamクラスには、さまざまなデータ型を書き込むための多くの書き込みメソッドが含まれていますが、特に1つのメソッドが際立っています。
public final void writeObject(Object x) throws IOException
上記のメソッドは、オブジェクトをシリアル化し、出力ストリームに送信します。同様に、ObjectInputStreamクラスには、オブジェクトを逆シリアル化するための次のメソッドが含まれています。
public final Object readObject() throws IOException, ClassNotFoundException
このメソッドは、ストリームから次のオブジェクトを取得し、それを逆シリアル化します。戻り値はObjectであるため、適切なデータ型にキャストする必要があります。
Javaでシリアル化がどのように機能するかを示すために、本の最初の方で説明したEmployeeクラスを使用します。次のEmployeeクラスがあり、Serializableインターフェースを実装するとします。
例
public class Employee implements java.io.Serializable {
public String name;
public String address;
public transient int SSN;
public int number;
public void mailCheck() {
System.out.println("Mailing a check to " + name + " " + address);
}
}
クラスが正常にシリアル化されるためには、2つの条件を満たす必要があることに注意してください-
クラスはjava.io.Serializableインターフェースを実装する必要があります。
クラス内のすべてのフィールドはシリアル化可能である必要があります。フィールドをシリアル化できない場合は、マークを付ける必要がありますtransient。
Java Standard Classがシリアライズ可能かどうかを知りたい場合は、クラスのドキュメントを確認してください。テストは簡単です。クラスがjava.io.Serializableを実装している場合、それはシリアライズ可能です。そうでなければ、そうではありません。
オブジェクトのシリアル化
ObjectOutputStreamクラスは、オブジェクトをシリアル化するために使用されます。次のSerializeDemoプログラムは、Employeeオブジェクトをインスタンス化し、ファイルにシリアル化します。
プログラムの実行が完了すると、employee.serという名前のファイルが作成されます。プログラムは出力を生成しませんが、コードを調べて、プログラムが何をしているかを判断しようとします。
Note −オブジェクトをファイルにシリアル化する場合、Javaの標準的な規則は、ファイルに .ser 拡張。
例
import java.io.*;
public class SerializeDemo {
public static void main(String [] args) {
Employee e = new Employee();
e.name = "Reyan Ali";
e.address = "Phokka Kuan, Ambehta Peer";
e.SSN = 11122333;
e.number = 101;
try {
FileOutputStream fileOut =
new FileOutputStream("/tmp/employee.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(e);
out.close();
fileOut.close();
System.out.printf("Serialized data is saved in /tmp/employee.ser");
} catch (IOException i) {
i.printStackTrace();
}
}
}
オブジェクトの逆シリアル化
次のDeserializeDemoプログラムは、SerializeDemoプログラムで作成されたEmployeeオブジェクトを逆シリアル化します。プログラムを研究し、その出力を決定してみてください-
例
import java.io.*;
public class DeserializeDemo {
public static void main(String [] args) {
Employee e = null;
try {
FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
e = (Employee) in.readObject();
in.close();
fileIn.close();
} catch (IOException i) {
i.printStackTrace();
return;
} catch (ClassNotFoundException c) {
System.out.println("Employee class not found");
c.printStackTrace();
return;
}
System.out.println("Deserialized Employee...");
System.out.println("Name: " + e.name);
System.out.println("Address: " + e.address);
System.out.println("SSN: " + e.SSN);
System.out.println("Number: " + e.number);
}
}
これにより、次の結果が生成されます-
出力
Deserialized Employee...
Name: Reyan Ali
Address:Phokka Kuan, Ambehta Peer
SSN: 0
Number:101
注意すべき重要な点は次のとおりです-
try / catchブロックは、readObject()メソッドによって宣言されたClassNotFoundExceptionをキャッチしようとします。JVMがオブジェクトを逆シリアル化できるようにするには、クラスのバイトコードを見つけることができなければなりません。オブジェクトの逆シリアル化中にJVMがクラスを見つけることができない場合、JVMはClassNotFoundExceptionをスローします。
readObject()の戻り値がEmployee参照にキャストされていることに注意してください。
オブジェクトがシリアル化されたときのSSNフィールドの値は11122333でしたが、フィールドが一時的であるため、この値は出力ストリームに送信されませんでした。デシリアライズされたEmployeeオブジェクトのSSNフィールドは0です。
ネットワークプログラミングという用語は、複数のデバイス(コンピューター)間で実行されるプログラムを作成することを指し、デバイスはすべてネットワークを使用して相互に接続されています。
J2SE APIのjava.netパッケージには、低レベルの通信の詳細を提供するクラスとインターフェースのコレクションが含まれているため、目前の問題の解決に焦点を当てたプログラムを作成できます。
java.netパッケージは、2つの一般的なネットワークプロトコルのサポートを提供します-
TCP− TCPは、伝送制御プロトコルの略で、2つのアプリケーション間の信頼性の高い通信を可能にします。TCPは通常、TCP / IPと呼ばれるインターネットプロトコルを介して使用されます。
UDP − UDPは、ユーザーデータグラムプロトコルの略で、アプリケーション間でデータのパケットを送信できるようにするコネクションレス型プロトコルです。
この章では、次の2つのテーマについて十分に理解しています。
Socket Programming −これはネットワーキングで最も広く使用されている概念であり、非常に詳細に説明されています。
URL Processing−これについては別途説明します。Java言語でのURL処理については、ここをクリックしてください。
ソケットプログラミング
ソケットは、TCPを使用して2台のコンピューター間の通信メカニズムを提供します。クライアントプログラムは、通信の最後にソケットを作成し、そのソケットをサーバーに接続しようとします。
接続が確立されると、サーバーは通信の最後にソケットオブジェクトを作成します。これで、クライアントとサーバーは、ソケットへの書き込みとソケットからの読み取りによって通信できるようになります。
java.net.Socketクラスはソケットを表し、java.net.ServerSocketクラスは、サーバープログラムがクライアントをリッスンしてクライアントとの接続を確立するためのメカニズムを提供します。
ソケットを使用して2台のコンピューター間でTCP接続を確立すると、次の手順が実行されます。
サーバーはServerSocketオブジェクトをインスタンス化し、どのポート番号の通信が行われるかを示します。
サーバーは、ServerSocketクラスのaccept()メソッドを呼び出します。このメソッドは、クライアントが指定されたポートでサーバーに接続するまで待機します。
サーバーが待機した後、クライアントはSocketオブジェクトをインスタンス化し、接続するサーバー名とポート番号を指定します。
Socketクラスのコンストラクターは、クライアントを指定されたサーバーとポート番号に接続しようとします。通信が確立されると、クライアントはサーバーと通信できるSocketオブジェクトを持ちます。
サーバー側では、accept()メソッドは、クライアントのソケットに接続されているサーバー上の新しいソケットへの参照を返します。
接続が確立された後、I / Oストリームを使用して通信を行うことができます。各ソケットには、OutputStreamとInputStreamの両方があります。クライアントのOutputStreamはサーバーのInputStreamに接続され、クライアントのInputStreamはサーバーのOutputStreamに接続されます。
TCPは双方向通信プロトコルであるため、データを両方のストリームに同時に送信できます。以下は、ソケットを実装するためのメソッドの完全なセットを提供する便利なクラスです。
ServerSocketクラスメソッド
ザ・ java.net.ServerSocket クラスは、サーバーアプリケーションがポートを取得し、クライアント要求をリッスンするために使用されます。
ServerSocketクラスには4つのコンストラクターがあります-
シニア番号 | 方法と説明 |
---|---|
1 | public ServerSocket(int port) throws IOException 指定されたポートにバインドされたサーバーソケットを作成しようとします。ポートがすでに別のアプリケーションによってバインドされている場合、例外が発生します。 |
2 | public ServerSocket(int port, int backlog) throws IOException 前のコンストラクターと同様に、backlogパラメーターは待機キューに格納する着信クライアントの数を指定します。 |
3 | public ServerSocket(int port, int backlog, InetAddress address) throws IOException 前のコンストラクターと同様に、InetAddressパラメーターはバインドするローカルIPアドレスを指定します。InetAddressは、複数のIPアドレスを持つ可能性のあるサーバーに使用され、サーバーがクライアント要求を受け入れるIPアドレスを指定できるようにします。 |
4 | public ServerSocket() throws IOException バインドされていないサーバーソケットを作成します。このコンストラクターを使用する場合、サーバーソケットをバインドする準備ができたら、bind()メソッドを使用します。 |
ServerSocketコンストラクターが例外をスローしない場合は、アプリケーションが指定されたポートに正常にバインドされ、クライアント要求の準備ができていることを意味します。
以下は、ServerSocketクラスの一般的なメソッドの一部です-
シニア番号 | 方法と説明 |
---|---|
1 | public int getLocalPort() サーバーソケットがリッスンしているポートを返します。このメソッドは、コンストラクターでポート番号として0を渡し、サーバーにポートを検出させる場合に役立ちます。 |
2 | public Socket accept() throws IOException 着信クライアントを待ちます。このメソッドは、setSoTimeout()メソッドを使用してタイムアウト値が設定されていると想定して、クライアントが指定されたポートでサーバーに接続するか、ソケットがタイムアウトするまでブロックします。それ以外の場合、このメソッドは無期限にブロックします。 |
3 | public void setSoTimeout(int timeout) accept()中にサーバーソケットがクライアントを待機する時間のタイムアウト値を設定します。 |
4 | public void bind(SocketAddress host, int backlog) SocketAddressオブジェクトの指定されたサーバーとポートにソケットをバインドします。引数なしのコンストラクターを使用してServerSocketをインスタンス化した場合は、このメソッドを使用します。 |
ServerSocketがaccept()を呼び出すと、クライアントが接続するまでメソッドは戻りません。クライアントが接続した後、ServerSocketは指定されていないポートに新しいソケットを作成し、この新しいソケットへの参照を返します。これで、クライアントとサーバーの間にTCP接続が存在し、通信を開始できます。
ソケットクラスメソッド
ザ・ java.net.Socketクラスは、クライアントとサーバーの両方が相互に通信するために使用するソケットを表します。クライアントはソケットオブジェクトをインスタンス化して取得しますが、サーバーはaccept()メソッドの戻り値からソケットオブジェクトを取得します。
Socketクラスには、クライアントがサーバーに接続するために使用する5つのコンストラクターがあります-
シニア番号 | 方法と説明 |
---|---|
1 | public Socket(String host, int port) throws UnknownHostException, IOException. このメソッドは、指定されたポートで指定されたサーバーに接続しようとします。このコンストラクターが例外をスローしない場合、接続は成功し、クライアントはサーバーに接続されます。 |
2 | public Socket(InetAddress host, int port) throws IOException このメソッドは、ホストがInetAddressオブジェクトで示されることを除いて、前のコンストラクターと同じです。 |
3 | public Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException. 指定されたホストとポートに接続し、ローカルホストの指定されたアドレスとポートにソケットを作成します。 |
4 | public Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException. このメソッドは、ホストが文字列ではなくInetAddressオブジェクトで示されることを除いて、前のコンストラクターと同じです。 |
5 | public Socket() 接続されていないソケットを作成します。connect()メソッドを使用して、このソケットをサーバーに接続します。 |
Socketコンストラクターが戻ると、Socketオブジェクトをインスタンス化するだけでなく、実際には指定されたサーバーとポートに接続しようとします。
Socketクラスで関心のあるいくつかのメソッドがここにリストされています。クライアントとサーバーの両方にSocketオブジェクトがあるため、これらのメソッドはクライアントとサーバーの両方から呼び出すことができます。
シニア番号 | 方法と説明 |
---|---|
1 | public void connect(SocketAddress host, int timeout) throws IOException このメソッドは、ソケットを指定されたホストに接続します。このメソッドは、引数なしのコンストラクターを使用してソケットをインスタンス化する場合にのみ必要です。 |
2 | public InetAddress getInetAddress() このメソッドは、このソケットが接続されている他のコンピューターのアドレスを返します。 |
3 | public int getPort() リモートマシンでソケットがバインドされているポートを返します。 |
4 | public int getLocalPort() ローカルマシンでソケットがバインドされているポートを返します。 |
5 | public SocketAddress getRemoteSocketAddress() リモートソケットのアドレスを返します。 |
6 | public InputStream getInputStream() throws IOException ソケットの入力ストリームを返します。入力ストリームは、リモートソケットの出力ストリームに接続されます。 |
7 | public OutputStream getOutputStream() throws IOException ソケットの出力ストリームを返します。出力ストリームは、リモートソケットの入力ストリームに接続されます。 |
8 | public void close() throws IOException ソケットを閉じます。これにより、このSocketオブジェクトはどのサーバーにも再度接続できなくなります。 |
InetAddressクラスメソッド
このクラスは、インターネットプロトコル(IP)アドレスを表します。ソケットプログラミングを行う際に必要となる以下の便利な方法を次に示します。
シニア番号 | 方法と説明 |
---|---|
1 | static InetAddress getByAddress(byte[] addr) 生のIPアドレスを指定してInetAddressオブジェクトを返します。 |
2 | static InetAddress getByAddress(String host, byte[] addr) 指定されたホスト名とIPアドレスに基づいてInetAddressを作成します。 |
3 | static InetAddress getByName(String host) ホストの名前を指定して、ホストのIPアドレスを決定します。 |
4 | String getHostAddress() テキスト表示でIPアドレス文字列を返します。 |
5 | String getHostName() このIPアドレスのホスト名を取得します。 |
6 | static InetAddress InetAddress getLocalHost() ローカルホストを返します。 |
7 | String toString() このIPアドレスを文字列に変換します。 |
ソケットクライアントの例
次のGreetingClientは、ソケットを使用してサーバーに接続し、グリーティングを送信してから、応答を待つクライアントプログラムです。
例
// File Name GreetingClient.java
import java.net.*;
import java.io.*;
public class GreetingClient {
public static void main(String [] args) {
String serverName = args[0];
int port = Integer.parseInt(args[1]);
try {
System.out.println("Connecting to " + serverName + " on port " + port);
Socket client = new Socket(serverName, port);
System.out.println("Just connected to " + client.getRemoteSocketAddress());
OutputStream outToServer = client.getOutputStream();
DataOutputStream out = new DataOutputStream(outToServer);
out.writeUTF("Hello from " + client.getLocalSocketAddress());
InputStream inFromServer = client.getInputStream();
DataInputStream in = new DataInputStream(inFromServer);
System.out.println("Server says " + in.readUTF());
client.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
ソケットサーバーの例
次のGreetingServerプログラムは、Socketクラスを使用して、コマンドライン引数で指定されたポート番号でクライアントをリッスンするサーバーアプリケーションの例です。
例
// File Name GreetingServer.java
import java.net.*;
import java.io.*;
public class GreetingServer extends Thread {
private ServerSocket serverSocket;
public GreetingServer(int port) throws IOException {
serverSocket = new ServerSocket(port);
serverSocket.setSoTimeout(10000);
}
public void run() {
while(true) {
try {
System.out.println("Waiting for client on port " +
serverSocket.getLocalPort() + "...");
Socket server = serverSocket.accept();
System.out.println("Just connected to " + server.getRemoteSocketAddress());
DataInputStream in = new DataInputStream(server.getInputStream());
System.out.println(in.readUTF());
DataOutputStream out = new DataOutputStream(server.getOutputStream());
out.writeUTF("Thank you for connecting to " + server.getLocalSocketAddress()
+ "\nGoodbye!");
server.close();
} catch (SocketTimeoutException s) {
System.out.println("Socket timed out!");
break;
} catch (IOException e) {
e.printStackTrace();
break;
}
}
}
public static void main(String [] args) {
int port = Integer.parseInt(args[0]);
try {
Thread t = new GreetingServer(port);
t.start();
} catch (IOException e) {
e.printStackTrace();
}
}
}
クライアントとサーバーをコンパイルしてから、次のようにサーバーを起動します-
$ java GreetingServer 6066
Waiting for client on port 6066...
次のようにクライアントプログラムを確認します-
出力
$ java GreetingClient localhost 6066
Connecting to localhost on port 6066
Just connected to localhost/127.0.0.1:6066
Server says Thank you for connecting to /127.0.0.1:6066
Goodbye!
Javaアプリケーションを使用して電子メールを送信するのは簡単ですが、最初に必要なのは JavaMail API そして Java Activation Framework (JAF) マシンにインストールされています。
JavaMailの最新バージョン(バージョン1.2)は、Javaの標準Webサイトからダウンロードできます。
JAFの最新バージョン(バージョン1.1.1)は、Javaの標準Webサイトからダウンロードできます。
これらのファイルをダウンロードして解凍します。新しく作成されたトップレベルのディレクトリに、両方のアプリケーション用の多数のjarファイルがあります。追加する必要がありますmail.jar そして activation.jar CLASSPATH内のファイル。
簡単なメールを送る
これは、マシンから簡単な電子メールを送信する例です。あなたのlocalhost インターネットに接続されており、電子メールを送信するのに十分な能力があります。
例
// File Name SendEmail.java
import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendEmail {
public static void main(String [] args) {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
// Assuming you are sending email from localhost
String host = "localhost";
// Get system properties
Properties properties = System.getProperties();
// Setup mail server
properties.setProperty("mail.smtp.host", host);
// Get the default Session object.
Session session = Session.getDefaultInstance(properties);
try {
// Create a default MimeMessage object.
MimeMessage message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
// Set Subject: header field
message.setSubject("This is the Subject Line!");
// Now set the actual message
message.setText("This is actual message");
// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
}
このプログラムをコンパイルして実行し、簡単な電子メールを送信します-
出力
$ java SendEmail
Sent message successfully....
複数の受信者に電子メールを送信する場合は、次の方法を使用して複数の電子メールIDを指定します-
void addRecipients(Message.RecipientType type, Address[] addresses)
throws MessagingException
パラメータの説明は次のとおりです-
type−これは、TO、CC、またはBCCに設定されます。ここで、CCはカーボンコピーを表し、BCCはブラックカーボンコピーを表します。例:Message.RecipientType.TO
addresses−これは電子メールIDの配列です。電子メールIDを指定するときは、InternetAddress()メソッドを使用する必要があります。
HTMLメールを送信する
これは、マシンからHTML電子メールを送信する例です。ここでは、localhost インターネットに接続されており、電子メールを送信するのに十分な能力があります。
この例は前の例と非常に似ていますが、ここではsetContent()メソッドを使用して、2番目の引数が「text / html」であるコンテンツを設定し、HTMLコンテンツがメッセージに含まれるように指定している点が異なります。
この例を使用すると、好きなだけ大きなHTMLコンテンツを送信できます。
例
// File Name SendHTMLEmail.java
import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendHTMLEmail {
public static void main(String [] args) {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
// Assuming you are sending email from localhost
String host = "localhost";
// Get system properties
Properties properties = System.getProperties();
// Setup mail server
properties.setProperty("mail.smtp.host", host);
// Get the default Session object.
Session session = Session.getDefaultInstance(properties);
try {
// Create a default MimeMessage object.
MimeMessage message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
// Set Subject: header field
message.setSubject("This is the Subject Line!");
// Send the actual HTML message, as big as you like
message.setContent("<h1>This is actual message</h1>", "text/html");
// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
}
このプログラムをコンパイルして実行し、HTMLメールを送信します-
出力
$ java SendHTMLEmail
Sent message successfully....
電子メールで添付ファイルを送信する
これは、マシンから添付ファイル付きの電子メールを送信する例です。ここでは、localhost インターネットに接続されており、電子メールを送信するのに十分な能力があります。
例
// File Name SendFileEmail.java
import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendFileEmail {
public static void main(String [] args) {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
// Assuming you are sending email from localhost
String host = "localhost";
// Get system properties
Properties properties = System.getProperties();
// Setup mail server
properties.setProperty("mail.smtp.host", host);
// Get the default Session object.
Session session = Session.getDefaultInstance(properties);
try {
// Create a default MimeMessage object.
MimeMessage message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.addRecipient(Message.RecipientType.TO,new InternetAddress(to));
// Set Subject: header field
message.setSubject("This is the Subject Line!");
// Create the message part
BodyPart messageBodyPart = new MimeBodyPart();
// Fill the message
messageBodyPart.setText("This is message body");
// Create a multipar message
Multipart multipart = new MimeMultipart();
// Set text message part
multipart.addBodyPart(messageBodyPart);
// Part two is attachment
messageBodyPart = new MimeBodyPart();
String filename = "file.txt";
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
multipart.addBodyPart(messageBodyPart);
// Send the complete message parts
message.setContent(multipart );
// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
}
このプログラムをコンパイルして実行し、HTMLメールを送信します-
出力
$ java SendFileEmail
Sent message successfully....
ユーザー認証部分
認証のためにユーザーIDとパスワードを電子メールサーバーに提供する必要がある場合は、これらのプロパティを次のように設定できます。
props.setProperty("mail.user", "myuser");
props.setProperty("mail.password", "mypwd");
残りの電子メール送信メカニズムは、上記で説明したとおりのままです。
Javaはマルチスレッドプログラミング言語です。つまり、Javaを使用してマルチスレッドプログラムを開発できます。マルチスレッドプログラムには、同時に実行できる2つ以上のパーツが含まれており、各パーツは、特にコンピューターに複数のCPUがある場合に、使用可能なリソースを最適に利用して、異なるタスクを同時に処理できます。
定義上、マルチタスクとは、複数のプロセスがCPUなどの共通の処理リソースを共有する場合です。マルチスレッドは、マルチタスクの概念をアプリケーションに拡張し、単一のアプリケーション内の特定の操作を個々のスレッドに分割できます。各スレッドは並行して実行できます。OSは、処理時間を異なるアプリケーション間だけでなく、アプリケーション内の各スレッド間でも分割します。
マルチスレッドを使用すると、同じプログラムで複数のアクティビティを同時に進行できるように記述できます。
スレッドのライフサイクル
スレッドは、そのライフサイクルのさまざまな段階を通過します。たとえば、スレッドが作成され、開始され、実行されてから終了します。次の図は、スレッドの完全なライフサイクルを示しています。
以下はライフサイクルの段階です-
New−新しいスレッドは、新しい状態でライフサイクルを開始します。プログラムがスレッドを開始するまで、この状態のままになります。とも呼ばれますborn thread。
Runnable−新しく生まれたスレッドが開始されると、スレッドは実行可能になります。この状態のスレッドは、そのタスクを実行していると見なされます。
Waiting−スレッドが別のスレッドがタスクを実行するのを待機している間に、スレッドが待機状態に移行する場合があります。別のスレッドが待機中のスレッドに実行を継続するように通知した場合にのみ、スレッドは実行可能状態に戻ります。
Timed Waiting−実行可能なスレッドは、指定された時間間隔で時間指定待機状態に入ることができます。この状態のスレッドは、その時間間隔が経過するか、待機中のイベントが発生すると、実行可能状態に戻ります。
Terminated (Dead) −実行可能なスレッドは、タスクを完了するか、その他の方法で終了すると、終了状態になります。
スレッドの優先順位
すべてのJavaスレッドには、オペレーティングシステムがスレッドがスケジュールされる順序を決定するのに役立つ優先順位があります。
Javaスレッドの優先順位は、MIN_PRIORITY(定数1)からMAX_PRIORITY(定数10)の間の範囲にあります。デフォルトでは、すべてのスレッドにNORM_PRIORITY(定数5)が優先されます。
優先度の高いスレッドはプログラムにとってより重要であり、優先度の低いスレッドの前にプロセッサ時間を割り当てる必要があります。ただし、スレッドの優先順位は、スレッドが実行される順序を保証することはできず、プラットフォームに大きく依存します。
実行可能なインターフェイスを実装してスレッドを作成する
クラスがスレッドとして実行されることを意図している場合は、実装することでこれを実現できます。 Runnableインターフェース。3つの基本的な手順に従う必要があります-
ステップ1
最初のステップとして、によって提供されるrun()メソッドを実装する必要があります。 Runnableインターフェース。このメソッドはスレッドのエントリポイントを提供し、完全なビジネスロジックをこのメソッド内に配置します。以下は、run()メソッドの簡単な構文です。
public void run( )
ステップ2
2番目のステップとして、インスタンス化する Thread 次のコンストラクタを使用するオブジェクト-
Thread(Runnable threadObj, String threadName);
ここで、threadObjは、を実装するクラスのインスタンスです。Runnable インターフェースと threadName 新しいスレッドに付けられた名前です。
ステップ3
スレッドオブジェクトが作成されたら、を呼び出すことで開始できます start()run()メソッドの呼び出しを実行するメソッド。以下はstart()メソッドの簡単な構文です-
void start();
例
これは、新しいスレッドを作成して実行を開始する例です-
class RunnableDemo implements Runnable {
private Thread t;
private String threadName;
RunnableDemo( String name) {
threadName = name;
System.out.println("Creating " + threadName );
}
public void run() {
System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i--) {
System.out.println("Thread: " + threadName + ", " + i);
// Let the thread sleep for a while.
Thread.sleep(50);
}
} catch (InterruptedException e) {
System.out.println("Thread " + threadName + " interrupted.");
}
System.out.println("Thread " + threadName + " exiting.");
}
public void start () {
System.out.println("Starting " + threadName );
if (t == null) {
t = new Thread (this, threadName);
t.start ();
}
}
}
public class TestThread {
public static void main(String args[]) {
RunnableDemo R1 = new RunnableDemo( "Thread-1");
R1.start();
RunnableDemo R2 = new RunnableDemo( "Thread-2");
R2.start();
}
}
これにより、次の結果が生成されます-
出力
Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.
スレッドクラスを拡張してスレッドを作成する
スレッドを作成する2番目の方法は、拡張する新しいクラスを作成することです。 Thread次の2つの簡単な手順を使用してクラスを作成します。このアプローチにより、Threadクラスで使用可能なメソッドを使用して作成された複数のスレッドをより柔軟に処理できます。
ステップ1
オーバーライドする必要があります run( )Threadクラスで使用可能なメソッド。このメソッドはスレッドのエントリポイントを提供し、完全なビジネスロジックをこのメソッド内に配置します。以下はrun()メソッドの簡単な構文です-
public void run( )
ステップ2
スレッドオブジェクトが作成されたら、を呼び出すことで開始できます start()run()メソッドの呼び出しを実行するメソッド。以下はstart()メソッドの簡単な構文です-
void start( );
例
これは、スレッドを拡張するために書き直された前述のプログラムです-
class ThreadDemo extends Thread {
private Thread t;
private String threadName;
ThreadDemo( String name) {
threadName = name;
System.out.println("Creating " + threadName );
}
public void run() {
System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i--) {
System.out.println("Thread: " + threadName + ", " + i);
// Let the thread sleep for a while.
Thread.sleep(50);
}
} catch (InterruptedException e) {
System.out.println("Thread " + threadName + " interrupted.");
}
System.out.println("Thread " + threadName + " exiting.");
}
public void start () {
System.out.println("Starting " + threadName );
if (t == null) {
t = new Thread (this, threadName);
t.start ();
}
}
}
public class TestThread {
public static void main(String args[]) {
ThreadDemo T1 = new ThreadDemo( "Thread-1");
T1.start();
ThreadDemo T2 = new ThreadDemo( "Thread-2");
T2.start();
}
}
これにより、次の結果が生成されます-
出力
Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.
スレッドメソッド
以下は、Threadクラスで使用可能な重要なメソッドのリストです。
シニア番号 | 方法と説明 |
---|---|
1 | public void start() 別の実行パスでスレッドを開始してから、このThreadオブジェクトでrun()メソッドを呼び出します。 |
2 | public void run() このThreadオブジェクトが別のRunnableターゲットを使用してインスタンス化された場合、run()メソッドはそのRunnableオブジェクトで呼び出されます。 |
3 | public final void setName(String name) Threadオブジェクトの名前を変更します。名前を取得するためのgetName()メソッドもあります。 |
4 | public final void setPriority(int priority) このThreadオブジェクトの優先度を設定します。可能な値は1から10の間です。 |
5 | public final void setDaemon(boolean on) trueのパラメーターは、このスレッドをデーモンスレッドとして示します。 |
6 | public final void join(long millisec) 現在のスレッドは2番目のスレッドでこのメソッドを呼び出し、2番目のスレッドが終了するか、指定されたミリ秒数が経過するまで、現在のスレッドをブロックします。 |
7 | public void interrupt() このスレッドを中断し、何らかの理由でブロックされた場合は実行を継続します。 |
8 | public final boolean isAlive() スレッドが生きている場合、つまりスレッドが開始された後、実行が完了する前の場合はいつでもtrueを返します。 |
前のメソッドは、特定のThreadオブジェクトで呼び出されます。Threadクラスの次のメソッドは静的です。静的メソッドの1つを呼び出すと、現在実行中のスレッドで操作が実行されます。
シニア番号 | 方法と説明 |
---|---|
1 | public static void yield() 現在実行中のスレッドが、スケジュールを待機している同じ優先度の他のスレッドに譲ります。 |
2 | public static void sleep(long millisec) 現在実行中のスレッドを、少なくとも指定されたミリ秒数の間ブロックします。 |
3 | public static boolean holdsLock(Object x) 現在のスレッドが指定されたオブジェクトのロックを保持している場合はtrueを返します。 |
4 | public static Thread currentThread() 現在実行中のスレッドへの参照を返します。これは、このメソッドを呼び出すスレッドです。 |
5 | public static void dumpStack() 現在実行中のスレッドのスタックトレースを出力します。これは、マルチスレッドアプリケーションをデバッグするときに役立ちます。 |
例
次のThreadClassDemoプログラムは、Threadクラスのこれらのメソッドのいくつかを示しています。クラスを考えてみましょうDisplayMessage 実装する Runnable −
// File Name : DisplayMessage.java
// Create a thread to implement Runnable
public class DisplayMessage implements Runnable {
private String message;
public DisplayMessage(String message) {
this.message = message;
}
public void run() {
while(true) {
System.out.println(message);
}
}
}
以下は、Threadクラスを拡張する別のクラスです-
// File Name : GuessANumber.java
// Create a thread to extentd Thread
public class GuessANumber extends Thread {
private int number;
public GuessANumber(int number) {
this.number = number;
}
public void run() {
int counter = 0;
int guess = 0;
do {
guess = (int) (Math.random() * 100 + 1);
System.out.println(this.getName() + " guesses " + guess);
counter++;
} while(guess != number);
System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
}
}
以下は、上記で定義されたクラスを利用するメインプログラムです-
// File Name : ThreadClassDemo.java
public class ThreadClassDemo {
public static void main(String [] args) {
Runnable hello = new DisplayMessage("Hello");
Thread thread1 = new Thread(hello);
thread1.setDaemon(true);
thread1.setName("hello");
System.out.println("Starting hello thread...");
thread1.start();
Runnable bye = new DisplayMessage("Goodbye");
Thread thread2 = new Thread(bye);
thread2.setPriority(Thread.MIN_PRIORITY);
thread2.setDaemon(true);
System.out.println("Starting goodbye thread...");
thread2.start();
System.out.println("Starting thread3...");
Thread thread3 = new GuessANumber(27);
thread3.start();
try {
thread3.join();
} catch (InterruptedException e) {
System.out.println("Thread interrupted.");
}
System.out.println("Starting thread4...");
Thread thread4 = new GuessANumber(75);
thread4.start();
System.out.println("main() is ending...");
}
}
これにより、次の結果が得られます。この例を何度も試すことができ、毎回異なる結果が得られます。
出力
Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......
主要なJavaマルチスレッドの概念
Javaでマルチスレッドプログラミングを行う場合、次の概念が非常に便利である必要があります。
スレッド同期とは何ですか?
スレッド間通信の処理
スレッドデッドロックの処理
主要なスレッド操作
アン appletは、Webブラウザで実行されるJavaプログラムです。アプレットは、Java API全体を自由に使用できるため、完全に機能するJavaアプリケーションにすることができます。
アプレットとスタンドアロンJavaアプリケーションの間には、次のようないくつかの重要な違いがあります。
アプレットは、java.applet.Appletクラスを拡張するJavaクラスです。
main()メソッドはアプレットで呼び出されず、アプレットクラスはmain()を定義しません。
アプレットは、HTMLページに埋め込まれるように設計されています。
ユーザーがアプレットを含むHTMLページを表示すると、アプレットのコードがユーザーのマシンにダウンロードされます。
アプレットを表示するには、JVMが必要です。JVMは、Webブラウザーのプラグインまたは別のランタイム環境のいずれかです。
ユーザーのマシン上のJVMは、アプレットクラスのインスタンスを作成し、アプレットの存続期間中にさまざまなメソッドを呼び出します。
アプレットには、Webブラウザによって適用される厳格なセキュリティルールがあります。アプレットのセキュリティは、サンドボックスセキュリティと呼ばれることが多く、従わなければならないさまざまなルールを使用して、サンドボックスで遊んでいる子供とアプレットを比較します。
アプレットに必要な他のクラスは、単一のJavaアーカイブ(JAR)ファイルでダウンロードできます。
アプレットのライフサイクル
Appletクラスの4つのメソッドは、深刻なアプレットを構築するためのフレームワークを提供します。
init−このメソッドは、アプレットに必要な初期化を対象としています。アプレットタグ内のparamタグが処理された後に呼び出されます。
start−このメソッドは、ブラウザがinitメソッドを呼び出した後に自動的に呼び出されます。また、ユーザーが他のページに移動した後、アプレットを含むページに戻るたびに呼び出されます。
stop−このメソッドは、ユーザーがアプレットが置かれているページから移動すると自動的に呼び出されます。したがって、同じアプレットで繰り返し呼び出すことができます。
destroy−このメソッドは、ブラウザが正常にシャットダウンした場合にのみ呼び出されます。アプレットはHTMLページ上に存在することを目的としているため、通常、ユーザーがアプレットを含むページを離れた後、リソースを残してはなりません。
paint− start()メソッドの直後、およびアプレットがブラウザで自身を再描画する必要があるときはいつでも呼び出されます。paint()メソッドは、実際にはjava.awtから継承されています。
「Hello、World」アプレット
以下は、HelloWorldApplet.javaという名前の単純なアプレットです。
import java.applet.*;
import java.awt.*;
public class HelloWorldApplet extends Applet {
public void paint (Graphics g) {
g.drawString ("Hello World", 25, 50);
}
}
これらのインポートステートメントは、クラスをアプレットクラスのスコープに入れます-
- java.applet.Applet
- java.awt.Graphics
これらのインポートステートメントがないと、Javaコンパイラはアプレットクラスが参照するアプレットとグラフィックスのクラスを認識しません。
アプレットクラス
すべてのアプレットは、java.applet.Appletクラスの拡張です。基本アプレットクラスは、派生アプレットクラスがブラウザコンテキストから情報とサービスを取得するために呼び出すことができるメソッドを提供します。
これらには、次のことを行うメソッドが含まれます-
- アプレットパラメータを取得する
- アプレットを含むHTMLファイルのネットワーク上の場所を取得します
- アプレットクラスディレクトリのネットワーク上の場所を取得します
- ブラウザにステータスメッセージを出力する
- 画像を取得する
- オーディオクリップを取得する
- オーディオクリップを再生する
- アプレットのサイズを変更します
さらに、Appletクラスは、ビューアまたはブラウザがアプレットに関する情報を取得し、アプレットの実行を制御するためのインターフェイスを提供します。視聴者は-
- アプレットの作成者、バージョン、および著作権に関する情報を要求する
- アプレットが認識するパラメータの説明を要求する
- アプレットを初期化します
- アプレットを破棄します
- アプレットの実行を開始します
- アプレットの実行を停止します
アプレットクラスは、これらの各メソッドのデフォルトの実装を提供します。これらの実装は、必要に応じてオーバーライドできます。
「Hello、World」アプレットはそのままで完成します。オーバーライドされる唯一のメソッドは、ペイントメソッドです。
アプレットの呼び出し
アプレットは、HTMLファイルにディレクティブを埋め込み、アプレットビューアまたはJava対応ブラウザを介してファイルを表示することで呼び出すことができます。
<applet>タグは、アプレットをHTMLファイルに埋め込むための基礎です。以下は、「Hello、World」アプレットを呼び出す例です。
<html>
<title>The Hello, World Applet</title>
<hr>
<applet code = "HelloWorldApplet.class" width = "320" height = "120">
If your browser was Java-enabled, a "Hello, World"
message would appear here.
</applet>
<hr>
</html>
Note− HTMLアプレットタグを参照して、HTMLからアプレットを呼び出す方法の詳細を理解できます。
<applet>タグのcode属性は必須です。実行するアプレットクラスを指定します。アプレットが実行されるパネルの初期サイズを指定するには、幅と高さも必要です。アプレットディレクティブは、</ applet>タグで閉じる必要があります。
アプレットがパラメータを受け取る場合、<applet>と</ applet>の間に<param>タグを追加することでパラメータに値を渡すことができます。ブラウザは、アプレットタグ間のテキストやその他のタグを無視します。
Javaに対応していないブラウザは、<applet>と</ applet>を処理しません。したがって、アプレットに関係なく、タグの間に表示されるものはすべて、Java対応でないブラウザで表示されます。
ビューアまたはブラウザは、ドキュメントの場所でコンパイルされたJavaコードを探します。それ以外の場合は、次のように<applet>タグのcodebase属性を使用します-
<applet codebase = "https://amrood.com/applets" code = "HelloWorldApplet.class"
width = "320" height = "120">
アプレットがデフォルト以外のパッケージにある場合は、保持パッケージをコード属性でピリオド文字(。)を使用して指定し、パッケージ/クラスコンポーネントを区切る必要があります。例-
<applet = "mypackage.subpackage.TestApplet.class"
width = "320" height = "120">
アプレットパラメータの取得
次の例は、アプレットがドキュメントで指定されたセットアップパラメータに応答するようにする方法を示しています。このアプレットは、黒と2番目の色の市松模様を表示します。
2番目の色と各正方形のサイズは、ドキュメント内のアプレットへのパラメータとして指定できます。
CheckerAppletは、init()メソッドでパラメーターを取得します。また、paint()メソッドでパラメータを取得する場合もあります。ただし、値を取得して設定を保存するのは、更新のたびではなく、アプレットの開始時に1回行うと便利で効率的です。
アプレットビューアまたはブラウザは、実行する各アプレットのinit()メソッドを呼び出します。ビューアは、アプレットをロードした直後に、init()を1回呼び出します。(Applet.init()は何もしないように実装されています。)デフォルトの実装をオーバーライドして、カスタム初期化コードを挿入します。
Applet.getParameter()メソッドは、パラメータ名を指定してパラメータをフェッチします(パラメータの値は常に文字列です)。値が数値またはその他の文字以外のデータである場合は、文字列を解析する必要があります。
以下はCheckerApplet.javaのスケルトンです-
import java.applet.*;
import java.awt.*;
public class CheckerApplet extends Applet {
int squareSize = 50; // initialized to default size
public void init() {}
private void parseSquareSize (String param) {}
private Color parseColor (String param) {}
public void paint (Graphics g) {}
}
これがCheckerAppletのinit()メソッドとprivate parseSquareSize()メソッドです-
public void init () {
String squareSizeParam = getParameter ("squareSize");
parseSquareSize (squareSizeParam);
String colorParam = getParameter ("color");
Color fg = parseColor (colorParam);
setBackground (Color.black);
setForeground (fg);
}
private void parseSquareSize (String param) {
if (param == null) return;
try {
squareSize = Integer.parseInt (param);
} catch (Exception e) {
// Let default value remain
}
}
アプレットはparseSquareSize()を呼び出して、squareSizeパラメーターを解析します。parseSquareSize()は、ライブラリメソッドInteger.parseInt()を呼び出します。このメソッドは、文字列を解析して整数を返します。Integer.parseInt()は、引数が無効な場合は常に例外をスローします。
したがって、parseSquareSize()は、不正な入力でアプレットが失敗することを許可するのではなく、例外をキャッチします。
アプレットはparseColor()を呼び出して、colorパラメータをColor値に解析します。parseColor()は、一連の文字列比較を実行して、パラメーター値を事前定義された色の名前に一致させます。このアプレットを機能させるには、これらのメソッドを実装する必要があります。
アプレットパラメータの指定
以下は、CheckerAppletが埋め込まれたHTMLファイルの例です。HTMLファイルは、<param>タグを使用してアプレットに両方のパラメータを指定します。
<html>
<title>Checkerboard Applet</title>
<hr>
<applet code = "CheckerApplet.class" width = "480" height = "320">
<param name = "color" value = "blue">
<param name = "squaresize" value = "30">
</applet>
<hr>
</html>
Note −パラメータ名では大文字と小文字は区別されません。
アプリケーションのアプレットへの変換
グラフィカルJavaアプリケーション(つまり、AWTを使用し、Javaプログラムランチャーで開始できるアプリケーション)を、Webページに埋め込むことができるアプレットに変換するのは簡単です。
以下は、アプリケーションをアプレットに変換するための特定の手順です。
アプレットコードをロードするための適切なタグを使用してHTMLページを作成します。
JAppletクラスのサブクラスを指定します。このクラスを公開します。そうしないと、アプレットをロードできません。
アプリケーションのmainメソッドを削除します。アプリケーションのフレームウィンドウを作成しないでください。アプリケーションはブラウザ内に表示されます。
初期化コードをフレームウィンドウコンストラクタからアプレットのinitメソッドに移動します。アプレットオブジェクトを明示的に作成する必要はありません。ブラウザはそれをインスタンス化し、initメソッドを呼び出します。
setSizeの呼び出しを削除します。アプレットの場合、サイズ設定はHTMLファイルの幅と高さのパラメータを使用して行われます。
setDefaultCloseOperationの呼び出しを削除します。アプレットを閉じることはできません。ブラウザが終了すると終了します。
アプリケーションがsetTitleを呼び出す場合は、メソッドの呼び出しを削除します。アプレットにタイトルバーを付けることはできません。(もちろん、HTMLタイトルタグを使用して、Webページ自体にタイトルを付けることができます。)
setVisible(true)を呼び出さないでください。アプレットは自動的に表示されます。
イベント処理
アプレットは、Containerクラスからイベント処理メソッドのグループを継承します。Containerクラスは、特定のタイプのイベントを処理するためのprocessKeyEventやprocessMouseEventなどのいくつかのメソッドを定義し、次にprocessEventと呼ばれる1つのキャッチオールメソッドを定義します。
イベントに反応するには、アプレットが適切なイベント固有のメソッドをオーバーライドする必要があります。
import java.awt.event.MouseListener;
import java.awt.event.MouseEvent;
import java.applet.Applet;
import java.awt.Graphics;
public class ExampleEventHandling extends Applet implements MouseListener {
StringBuffer strBuffer;
public void init() {
addMouseListener(this);
strBuffer = new StringBuffer();
addItem("initializing the apple ");
}
public void start() {
addItem("starting the applet ");
}
public void stop() {
addItem("stopping the applet ");
}
public void destroy() {
addItem("unloading the applet");
}
void addItem(String word) {
System.out.println(word);
strBuffer.append(word);
repaint();
}
public void paint(Graphics g) {
// Draw a Rectangle around the applet's display area.
g.drawRect(0, 0,
getWidth() - 1,
getHeight() - 1);
// display the string inside the rectangle.
g.drawString(strBuffer.toString(), 10, 20);
}
public void mouseEntered(MouseEvent event) {
}
public void mouseExited(MouseEvent event) {
}
public void mousePressed(MouseEvent event) {
}
public void mouseReleased(MouseEvent event) {
}
public void mouseClicked(MouseEvent event) {
addItem("mouse clicked! ");
}
}
さて、このアプレットを次のように呼びましょう-
<html>
<title>Event Handling</title>
<hr>
<applet code = "ExampleEventHandling.class"
width = "300" height = "300">
</applet>
<hr>
</html>
最初に、アプレットは「アプレットを初期化しています。アプレットを開始しています」と表示します。次に、長方形の内側をクリックすると、「マウスがクリックされました」も表示されます。
画像の表示
アプレットは、GIF、JPEG、BMPなどの形式の画像を表示できます。アプレット内に画像を表示するには、java.awt.GraphicsクラスにあるdrawImage()メソッドを使用します。
以下は、画像を表示するためのすべての手順を示す例です。
import java.applet.*;
import java.awt.*;
import java.net.*;
public class ImageDemo extends Applet {
private Image image;
private AppletContext context;
public void init() {
context = this.getAppletContext();
String imageURL = this.getParameter("image");
if(imageURL == null) {
imageURL = "java.jpg";
}
try {
URL url = new URL(this.getDocumentBase(), imageURL);
image = context.getImage(url);
} catch (MalformedURLException e) {
e.printStackTrace();
// Display in browser status bar
context.showStatus("Could not load image!");
}
}
public void paint(Graphics g) {
context.showStatus("Displaying image");
g.drawImage(image, 0, 0, 200, 84, null);
g.drawString("www.javalicense.com", 35, 100);
}
}
さて、このアプレットを次のように呼びましょう-
<html>
<title>The ImageDemo applet</title>
<hr>
<applet code = "ImageDemo.class" width = "300" height = "200">
<param name = "image" value = "java.jpg">
</applet>
<hr>
</html>
オーディオの再生
アプレットは、java.appletパッケージのAudioClipインターフェイスで表されるオーディオファイルを再生できます。AudioClipインターフェイスには、次の3つのメソッドがあります。
public void play() −オーディオクリップを最初から1回再生します。
public void loop() −オーディオクリップを継続的に再生します。
public void stop() −オーディオクリップの再生を停止します。
AudioClipオブジェクトを取得するには、アプレットクラスのgetAudioClip()メソッドを呼び出す必要があります。getAudioClip()メソッドは、URLが実際のオーディオファイルに解決されるかどうかに関係なく、すぐに戻ります。オーディオクリップの再生が試行されるまで、オーディオファイルはダウンロードされません。
以下は、オーディオを再生するためのすべての手順を示す例です。
import java.applet.*;
import java.awt.*;
import java.net.*;
public class AudioDemo extends Applet {
private AudioClip clip;
private AppletContext context;
public void init() {
context = this.getAppletContext();
String audioURL = this.getParameter("audio");
if(audioURL == null) {
audioURL = "default.au";
}
try {
URL url = new URL(this.getDocumentBase(), audioURL);
clip = context.getAudioClip(url);
} catch (MalformedURLException e) {
e.printStackTrace();
context.showStatus("Could not load audio file!");
}
}
public void start() {
if(clip != null) {
clip.loop();
}
}
public void stop() {
if(clip != null) {
clip.stop();
}
}
}
さて、このアプレットを次のように呼びましょう-
<html>
<title>The ImageDemo applet</title>
<hr>
<applet code = "ImageDemo.class" width = "0" height = "0">
<param name = "audio" value = "test.wav">
</applet>
<hr>
</html>
PCでtest.wavを使用して、上記の例をテストできます。
Java言語は3種類のコメントをサポートしています-
シニア番号 | コメントと説明 |
---|---|
1 | /* text */ コンパイラーは/ *から* /までのすべてを無視します。 |
2 | //text コンパイラは//から行末までのすべてを無視します。 |
3 | /** documentation */ これはドキュメンテーションコメントであり、一般的には doc comment。ザ・JDK javadocツールは、自動生成されたドキュメントを準備するときにドキュメントコメントを使用します。 |
この章では、Javadocについて説明します。Javadocを利用してJavaコードの有用なドキュメントを生成する方法を見ていきます。
Javadocとは何ですか?
Javadocは、JDKに付属するツールであり、JavaソースコードからHTML形式のJavaコードドキュメントを生成するために使用されます。これには、事前定義された形式のドキュメントが必要です。
以下は、/ *…。* /内の行がJavaの複数行コメントである簡単な例です。同様に、//の前の行はJavaの単一行コメントです。
例
/**
* The HelloWorld program implements an application that
* simply displays "Hello World!" to the standard output.
*
* @author Zara Ali
* @version 1.0
* @since 2014-03-31
*/
public class HelloWorld {
public static void main(String[] args) {
// Prints Hello, World! on standard output.
System.out.println("Hello World!");
}
}
説明部分に必要なHTMLタグを含めることができます。たとえば、次の例では、見出しに<h1> .... </ h1>を使用し、段落区切りの作成に<p>を使用しています-
例
/**
* <h1>Hello, World!</h1>
* The HelloWorld program implements an application that
* simply displays "Hello World!" to the standard output.
* <p>
* Giving proper comments in your program makes it more
* user friendly and it is assumed as a high quality code.
*
*
* @author Zara Ali
* @version 1.0
* @since 2014-03-31
*/
public class HelloWorld {
public static void main(String[] args) {
// Prints Hello, World! on standard output.
System.out.println("Hello World!");
}
}
javadocタグ
javadocツールは次のタグを認識します-
鬼ごっこ | 説明 | 構文 |
---|---|---|
@著者 | クラスの作成者を追加します。 | @author name-text |
{@コード} | テキストをHTMLマークアップまたはネストされたjavadocタグとして解釈せずに、コードフォントでテキストを表示します。 | {@code text} |
{@docRoot} | 生成されたページから生成されたドキュメントのルートディレクトリへの相対パスを表します。 | {@docRoot} |
@deprecated | このAPIを使用しないことを示すコメントを追加します。 | @deprecated deprecatedtext |
@例外 | 追加します Throws 生成されたドキュメントの小見出しと、クラス名と説明テキスト。 | @exceptionクラス名の説明 |
{@inheritDoc} | からコメントを継承します nearest 継承可能なクラスまたは実装可能なインターフェイス。 | 直近のスーパークラスからのコメントを継承します。 |
{@リンク} | 指定されたパッケージ、クラス、または参照されたクラスのメンバー名のドキュメントを指す、表示されているテキストラベルを含むインラインリンクを挿入します。 | {@link package.class#member label} |
{@linkplain} | リンクのラベルがコードフォントではなくプレーンテキストで表示されることを除いて、{@ link}と同じです。 | {@linkplain package.class#member label} |
@param | 「パラメーター」セクションに、指定されたパラメーター名の後に指定された説明が続くパラメーターを追加します。 | @paramパラメータ名の説明 |
@return | 説明テキストを含む「返品」セクションを追加します。 | @returnの説明 |
@見る | 参照を指すリンクまたはテキストエントリを含む「関連項目」の見出しを追加します。 | @リファレンスを参照 |
@シリアル | デフォルトのシリアル化可能なフィールドのドキュメントコメントで使用されます。 | @serialフィールドの説明| 含める| 除外する |
@serialData | writeObject()またはwriteExternal()メソッドによって書き込まれたデータを文書化します。 | @serialDataデータの説明 |
@serialField | ObjectStreamFieldコンポーネントを文書化します。 | @serialFieldフィールド名フィールドタイプフィールドの説明 |
@since | 生成されたドキュメントに、指定されたsince-textを含む「Since」見出しを追加します。 | @リリース以降 |
@throws | @throwsタグと@exceptionタグは同義語です。 | @throwsクラス名の説明 |
{@値} | 静的フィールドのドキュメントコメントで{@value}が使用されている場合、その定数の値が表示されます。 | {@value package.class#field} |
@バージョン | -versionオプションを使用すると、生成されたドキュメントに、指定されたバージョンテキストを含む「バージョン」小見出しが追加されます。 | @versionバージョン-テキスト |
例
次のプログラムは、ドキュメントのコメントに使用できる重要なタグのいくつかを使用しています。要件に基づいて、他のタグを利用できます。
AddNumクラスに関するドキュメントはHTMLファイルAddNum.htmlで作成されますが、同時にindex.htmlという名前のマスターファイルも作成されます。
import java.io.*;
/**
* <h1>Add Two Numbers!</h1>
* The AddNum program implements an application that
* simply adds two given integer numbers and Prints
* the output on the screen.
* <p>
* <b>Note:</b> Giving proper comments in your program makes it more
* user friendly and it is assumed as a high quality code.
*
* @author Zara Ali
* @version 1.0
* @since 2014-03-31
*/
public class AddNum {
/**
* This method is used to add two integers. This is
* a the simplest form of a class method, just to
* show the usage of various javadoc Tags.
* @param numA This is the first paramter to addNum method
* @param numB This is the second parameter to addNum method
* @return int This returns sum of numA and numB.
*/
public int addNum(int numA, int numB) {
return numA + numB;
}
/**
* This is the main method which makes use of addNum method.
* @param args Unused.
* @return Nothing.
* @exception IOException On input error.
* @see IOException
*/
public static void main(String args[]) throws IOException {
AddNum obj = new AddNum();
int sum = obj.addNum(10, 20);
System.out.println("Sum of 10 and 20 is :" + sum);
}
}
ここで、javadocユーティリティを使用して上記のAddNum.javaファイルを次のように処理します-
$ javadoc AddNum.java
Loading source file AddNum.java...
Constructing Javadoc information...
Standard Doclet version 1.7.0_51
Building tree for all the packages and classes...
Generating /AddNum.html...
AddNum.java:36: warning - @return tag cannot be used in method with void return type.
Generating /package-frame.html...
Generating /package-summary.html...
Generating /package-tree.html...
Generating /constant-values.html...
Building index for all the packages and classes...
Generating /overview-tree.html...
Generating /index-all.html...
Generating /deprecated-list.html...
Building index for all classes...
Generating /allclasses-frame.html...
Generating /allclasses-noframe.html...
Generating /index.html...
Generating /help-doc.html...
1 warning
$
生成されたすべてのドキュメントは、ここで確認できます-AddNum。JDK 1.7を使用している場合、javadocは優れたものを生成しませんstylesheet.css、から標準スタイルシートをダウンロードして使用することをお勧めします https://docs.oracle.com/javase/7/docs/api/stylesheet.css