Java-quick-guide
Java-概要
Javaプログラミング言語は、もともとJames Goslingによって開始され、1995年にSun MicrosystemsのJavaプラットフォーム（Java 1.0 [J2SE]）のコアコンポーネントとしてリリースされたSun Microsystemsによって開発されました。
Java Standard Editionの最新リリースはJava SE 8です。 Javaの進歩とその普及により、さまざまなタイプのプラットフォームに適合する複数の構成が構築されました。 例：エンタープライズアプリケーション用のJ2EE、モバイルアプリケーション用のJ2ME。
新しいJ2バージョンは、それぞれJava SE、Java EE、およびJava MEに名前が変更されました。 Javaは* Write Once、Run Anywhereであることが保証されています*
Javaは-
- オブジェクト指向-Javaでは、すべてがオブジェクトです。 Javaはオブジェクトモデルに基づいているため、簡単に拡張できます。
- プラットフォーム非依存-CやC＆plus;＆plus;などの他の多くのプログラミング言語とは異なり、Javaがコンパイルされるとき、プラットフォーム固有のマシンではなく、プラットフォームに依存しないバイトコードにコンパイルされます。 このバイトコードはWeb経由で配布され、実行されているプラットフォームの仮想マシン（JVM）によって解釈されます。
- シンプル-Javaは簡単に学習できるように設計されています。 OOP Javaの基本概念を理解していれば、簡単に習得できます。
- 安全-Javaの安全な機能により、ウイルスやタンパーのないシステムを開発できます。 認証技術は公開鍵暗号化に基づいています。
- Architecture-neutral -Javaコンパイラは、アーキテクチャに中立なオブジェクトファイル形式を生成します。これにより、コンパイルされたコードがJavaランタイムシステムの存在下で多くのプロセッサで実行可能になります。
- ポータブル-アーキテクチャに中立であり、実装に依存する仕様の側面がないため、Javaはポータブルになります。 Javaのコンパイラは、POSIXサブセットである移植性の境界が明確なANSI Cで記述されています。
- 堅牢-Javaは、主にコンパイル時のエラーチェックとランタイムチェックに重点を置くことにより、エラーが発生しやすい状況を排除する努力をしています。
- マルチスレッド-Javaのマルチスレッド機能を使用すると、多くのタスクを同時に実行できるプログラムを作成できます。 この設計機能により、開発者はスムーズに実行できるインタラクティブなアプリケーションを構築できます。
- Interpreted -Javaバイトコードは、その場でネイティブマシン命令に変換され、どこにも保存されません。 リンクは漸進的で軽量のプロセスであるため、開発プロセスはより迅速で分析的です。
- 高性能-Just-In-Timeコンパイラーを使用することで、Javaは高性能を実現します。
- 分散-Javaはインターネットの分散環境用に設計されています。
- 動的-JavaはCやC＆plus;＆plus;よりも動的であると見なされます。進化する環境に適応するように設計されているためです。 Javaプログラムは、実行時のオブジェクトへのアクセスを検証および解決するために使用できる大量の実行時情報を保持できます。
Javaの歴史
James Goslingは、1991年6月に、彼の多くのセットトップボックスプロジェクトの1つで使用するJava言語プロジェクトを開始しました。 ゴスリングのオフィスの外に立っていたoの木にちなんで最初に「オーク」と呼ばれたこの言語も、「グリーン」という名前で呼ばれ、後にランダムな単語のリストからJavaに改名されました。
Sunは1995年に最初のパブリック実装をJava 1.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 200 MHzコンピューターが必要です。
また、次のソフトウェアが必要になります-
- Linux 7.1またはWindows xp/7/8オペレーティングシステム
- Java JDK 8
- Microsoftメモ帳またはその他のテキストエディター
このチュートリアルでは、Javaを使用してGUI、ネットワーク、およびWebアプリケーションを作成するために必要なスキルを提供します。
次は何ですか？
次の章では、Javaとそのドキュメントを入手する方法について説明します。 最後に、Javaをインストールし、Javaアプリケーションを開発するための環境を準備する方法について説明します。
Java-環境設定
この章では、Javaに適した環境を設定するさまざまな側面について説明します。
ローカル環境のセットアップ
Javaプログラミング言語用に環境をセットアップする場合は、このセクションで、マシンにJavaをダウンロードしてセットアップする方法を説明します。 環境を設定する手順は次のとおりです。
Java SEは、https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151l [Download Java]のリンクから無料で入手できます。 オペレーティングシステムに基づいてバージョンをダウンロードできます。
指示に従ってJavaをダウンロードし、*。exe *を実行して、マシンにJavaをインストールします。 マシンにJavaをインストールしたら、正しいインストールディレクトリを指すように環境変数を設定する必要があります-
Windows用のパスのセットアップ
_c：\ Program Files \ java \ jdk_ディレクトリにJavaをインストールしたと仮定します-
- 「マイコンピュータ」を右クリックして、「プロパティ」を選択します。
- 「詳細」タブの下の「環境変数」ボタンをクリックします。
- ここで、「Path」変数を変更して、Java実行可能ファイルへのパスも含まれるようにします。 たとえば、パスが現在「C：\ WINDOWS \ SYSTEM32」に設定されている場合、パスを「C：\ WINDOWS \ SYSTEM32; c：\ Program Files \ java \ jdk \ bin」に変更します。
Linux、UNIX、Solaris、FreeBSDのパスのセットアップ
環境変数PATHは、Javaバイナリがインストールされている場所を指すように設定する必要があります。 これがうまくいかない場合は、シェルのドキュメントを参照してください。
たとえば、_bash_をシェルとして使用する場合、次の行を '.bashrcの最後に追加します。export PATH =/path/to/java：$ PATH'
人気のあるJavaエディター
Javaプログラムを作成するには、テキストエディターが必要です。 市場にはさらに洗練されたIDEがあります。 しかし、今のところ、次のいずれかを検討することができます-
- メモ帳-Windowsマシンでは、メモ帳（このチュートリアルに推奨）、TextPadなどの単純なテキストエディタを使用できます。
- Netbeans -https://www.netbeans.org/indexlからダウンロードできるオープンソースで無料のJava IDE。
- Eclipse -eclipseオープンソースコミュニティが開発したJavaIDE。https://www.eclipse.org/からダウンロードできます。
次は何ですか？
次の章では、最初のJavaプログラムと、アプリケーションの開発に必要なJavaの重要な基本構文のいくつかを作成して実行する方法を説明します。
Java-基本構文
Javaプログラムを考えるとき、それは互いのメソッドを呼び出すことで通信するオブジェクトのコレクションとして定義できます。 ここで、クラス、オブジェクト、メソッド、およびインスタンス変数の意味を簡単に見てみましょう。
- オブジェクト-オブジェクトには状態と動作があります。 例：犬には、色、名前、品種、尾を振る、barえる、食べるなどの行動があります。 オブジェクトはクラスのインスタンスです。
- クラス-クラスは、そのタイプのオブジェクトがサポートする動作/状態を記述するテンプレート/設計図として定義できます。
- メソッド-メソッドは基本的に動作です。 クラスには多くのメソッドを含めることができます。 ロジックが書き込まれ、データが操作され、すべてのアクションが実行されるのはメソッドです。
- インスタンス変数-各オブジェクトには、インスタンス変数の一意のセットがあります。 オブジェクトの状態は、これらのインスタンス変数に割り当てられた値によって作成されます。
最初の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」と入力してプログラムを実行します。
- ウィンドウに「Hello World」と表示されます。
出力
C:\> javac MyFirstJavaProgram.java
C:\> java MyFirstJavaProgram
Hello World基本的な構文
Javaプログラムについては、次の点に留意することが非常に重要です。
- 大文字と小文字の区別-Javaでは大文字と小文字が区別されます。つまり、識別子 Hello と hello はJavaでは異なる意味を持ちます。
- クラス名-すべてのクラス名の最初の文字は大文字にする必要があります。 複数の単語を使用してクラスの名前を形成する場合、各内側の単語の最初の文字は大文字にする必要があります。 + 例： class MyFirstJavaClass
- メソッド名-すべてのメソッド名は小文字で始まる必要があります。 複数の単語を使用してメソッドの名前を形成する場合、各内側の単語の最初の文字は大文字にする必要があります。 + 例： public void myMethodName（）
- プログラムファイル名-プログラムファイルの名前はクラス名と完全に一致する必要があります。 +ファイルを保存するときは、クラス名を使用して保存し（Javaは大文字と小文字を区別します）、名前の最後に「.java」を追加する必要があります（ファイル名とクラス名が一致しない場合、プログラムはコンパイル）。 +ただし、ファイルにパブリッククラスが存在しない場合は、ファイル名がクラス名と異なる場合があることに注意してください。 また、ファイルにパブリッククラスを含めることは必須ではありません。 + 例：「MyFirstJavaProgram」がクラス名であると仮定します。 次に、ファイルを_'MyFirstJavaProgram.java'_として保存する必要があります
- * public static void main（String args []）*-Javaプログラムの処理は、すべてのJavaプログラムの必須部分であるmain（）メソッドから開始されます。
Java識別子
すべてのJavaコンポーネントには名前が必要です。 クラス、変数、およびメソッドに使用される名前は*識別子*と呼ばれます。
Javaでは、識別子について覚えておくべきポイントがいくつかあります。 彼らは次のとおりです-
- すべての識別子は、文字（A〜Zまたはa〜z）、通貨文字（$）、またはアンダースコア（_）で始まる必要があります。
- 最初の文字の後に、識別子は任意の文字の組み合わせを持つことができます。
- キーワードを識別子として使用することはできません。
- 最も重要なこととして、識別子は大文字と小文字が区別されます。
- 有効な識別子の例：年齢、$ salary、value、_ 1_value。
- 不正な識別子の例：123abc、-salary。
Java修飾子
他の言語と同様に、修飾子を使用して、クラス、メソッドなどを変更できます。 修飾子には2つのカテゴリがあります-
- アクセス修飾子-デフォルト、パブリック、保護、プライベート
- 非アクセス修飾子-final、abstract、strictfp
次のセクションで修飾子の詳細を検討します。
Java変数
以下は、Javaの変数の種類です-
- ローカル変数
- クラス変数（静的変数）
- インスタンス変数（非静的変数）
Java配列
配列は、同じタイプの複数の変数を格納するオブジェクトです。 ただし、配列自体はヒープ上のオブジェクトです。 宣言、構築、初期化の方法については、今後の章で説明します。
Java列挙
列挙型はJava 5.0で導入されました。 列挙型は、変数がいくつかの事前定義された値のいずれかを持つように制限します。 この列挙リストの値は、列挙と呼ばれます。
列挙型を使用すると、コード内のバグの数を減らすことができます。
たとえば、フレッシュジュースショップのアプリケーションを検討する場合、ガラスのサイズを小、中、大に制限することができます。 これにより、小、中、大以外のサイズを誰も注文できないようになります。
例
class FreshJuice {
enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
FreshJuiceSize size;
}
public class FreshJuiceTest {
public static void main(String args[]) {
FreshJuice juice = new FreshJuice();
juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
System.out.println("Size: " + juice.size);
}
}上記の例では、次の結果が生成されます-
出力
Size: MEDIUM注-列挙型は、それ自体またはクラス内で宣言できます。 メソッド、変数、コンストラクターも列挙内で定義できます。
Javaキーワード
次のリストは、Javaの予約語を示しています。 これらの予約語は、定数、変数、またはその他の識別子名として使用できません。
| abstract | assert | boolean | break |
| byte | case | catch | char |
| class | const | continue | default |
| do | double | else | enum |
| extends | final | finally | float |
| for | goto | if | implements |
| import | instanceof | int | interface |
| long | native | new | package |
| private | protected | public | return |
| short | static | strictfp | super |
| switch | synchronized | this | throw |
| throws | transient | try | void |
| volatile | while |
Javaでのコメント
Javaは、CおよびC＆plus;＆plus;と非常によく似た単一行および複数行のコメントをサポートします。 コメント内で使用可能なすべての文字は、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では、クラスはクラスから派生できます。 基本的に、新しいクラスを作成する必要があり、ここに必要なコードの一部が既に含まれている場合、既存のコードから新しいクラスを派生させることができます。
この概念により、新しいクラスのコードを書き直すことなく、既存のクラスのフィールドとメソッドを再利用できます。 このシナリオでは、既存のクラスは*スーパークラス*と呼ばれ、派生クラスは*サブクラス*と呼ばれます。
インターフェース
Java言語では、インターフェイスは、相互の通信方法に関するオブジェクト間のコントラクトとして定義できます。 インターフェイスは、継承の概念に関して重要な役割を果たします。
インターフェイスはメソッドを定義し、派生クラス（サブクラス）が使用する必要があります。 しかし、メソッドの実装は完全にサブクラス次第です。
次は何ですか？
次のセクションでは、Javaプログラミングのオブジェクトとクラスについて説明します。 セッションの終わりに、オブジェクトとは何か、Javaのクラスは何かを明確に把握できるようになります。
Java-オブジェクトとクラス
Javaはオブジェクト指向言語です。 オブジェクト指向機能を備えた言語として、Javaは以下の基本概念をサポートしています-
- 多型
- 継承
- カプセル化
- 抽象化
- クラス
- オブジェクト
- インスタンス
- 方法
- メッセージの受け渡し
この章では、概念-クラスとオブジェクト-を調べます。
- オブジェクト-オブジェクトには状態と動作があります。 例：犬には、色、名前、品種、行動などの状態があり、尾を振ったり、,えたり、食べたりします。 オブジェクトはクラスのインスタンスです。
- クラス-クラスは、そのタイプのオブジェクトがサポートする動作/状態を記述するテンプレート/設計図として定義できます。
Javaのオブジェクト
オブジェクトとは何かを詳しく見てみましょう。 現実の世界を考えると、私たちの周りには多くの物体、車、犬、人間などを見つけることができます。 これらすべてのオブジェクトには、状態と動作があります。
犬を考えると、その状態は-名前、品種、色、そして行動は-barえる、尻尾を振る、走るです。
ソフトウェアオブジェクトを実際のオブジェクトと比較すると、非常によく似た特性があります。
ソフトウェアオブジェクトには、状態と動作もあります。 ソフトウェアオブジェクトの状態はフィールドに格納され、動作はメソッドを介して表示されます。
そのため、ソフトウェア開発では、メソッドはオブジェクトの内部状態で動作し、オブジェクト間の通信はメソッドを介して行われます。
Javaのクラス
クラスは、個々のオブジェクトが作成される青写真です。
以下はクラスのサンプルです。
例
public class Dog {
String breed;
int age;
String color;
void barking() {
}
void hungry() {
}
void sleeping() {
}
}クラスには、次の変数タイプのいずれかを含めることができます。
- ローカル変数-メソッド、コンストラクタ、またはブロック内で定義された変数はローカル変数と呼ばれます。 変数はメソッド内で宣言および初期化され、メソッドが完了すると変数は破棄されます。
- インスタンス変数-インスタンス変数は、クラス内のメソッドですが、メソッドの外部の変数です。 これらの変数は、クラスがインスタンス化されるときに初期化されます。 インスタンス変数は、その特定のクラスのメソッド、コンストラクター、またはブロック内からアクセスできます。
- クラス変数-クラス変数は、静的キーワードを使用して、メソッド内ではなくクラス内で宣言された変数です。
クラスには、さまざまな種類のメソッドの値にアクセスするための任意の数のメソッドを含めることができます。 上記の例では、barking（）、hungry（）、sleeping（）がメソッドです。
以下は、Java言語のクラスを調べるときに議論する必要がある重要なトピックの一部です。
コンストラクタ
クラスについて議論するとき、最も重要なサブトピックの1つはコンストラクタです。 すべてのクラスにはコンストラクターがあります。 クラスのコンストラクターを明示的に記述しない場合、Javaコンパイラーはそのクラスのデフォルトコンストラクターを構築します。
新しいオブジェクトが作成されるたびに、少なくとも1つのコンストラクターが呼び出されます。 コンストラクターの主な規則は、コンストラクターがクラスと同じ名前を持つ必要があるということです。 クラスには複数のコンストラクターを含めることができます。
以下は、コンストラクタの例です-
例
public class Puppy {
public Puppy() {
}
public Puppy(String name) {
//This constructor has one parameter, name.
}
}Javaは、シングルトン[シングルトンクラス]を使用してlink：/java/javaもサポートしています。この場合、クラスのインスタンスを1つだけ作成できます。
注-コンストラクタには2つの異なるタイプがあります。 コンストラクタについては、後続の章で詳しく説明します。
オブジェクトを作成する
前述のように、クラスはオブジェクトの青写真を提供します。 基本的に、オブジェクトはクラスから作成されます。 Javaでは、新しいキーワードを使用して新しいオブジェクトを作成します。
クラスからオブジェクトを作成する場合、3つのステップがあります-
- 宣言-オブジェクト型の変数名を持つ変数宣言。
- インスタンス-'new’キーワードは、オブジェクトを作成するために使用されます。
- 初期化-'new’キーワードの後にコンストラクターの呼び出しが続きます。 この呼び出しは、新しいオブジェクトを初期化します。
以下は、オブジェクトを作成する例です-
例
public class Puppy {
public Puppy(String name) {
//This constructor has one parameter, name.
System.out.println("Passed Name is :" + name );
}
public static void main(String []args) {
//Following statement would create an object myPuppy
Puppy myPuppy = new Puppy( "tommy" );
}
}上記のプログラムをコンパイルして実行すると、次の結果が生成されます-
出力
Passed Name is :tommyインスタンス変数とメソッドへのアクセス
インスタンス変数とメソッドは、作成されたオブジェクトを介してアクセスされます。 インスタンス変数にアクセスするには、次が完全修飾パスです-
/*First create an object*/
ObjectReference = new Constructor();
/*Now call a variable as follows*/
ObjectReference.variableName;
/*Now you can call a class method as follows*/
ObjectReference.MethodName();例
この例では、クラスのインスタンス変数とメソッドにアクセスする方法を説明します。
public class Puppy {
int puppyAge;
public Puppy(String name) {
//This constructor has one parameter, name.
System.out.println("Name chosen is :" + name );
}
public void setAge( int age ) {
puppyAge = age;
}
public int getAge( ) {
System.out.println("Puppy's age is :" + puppyAge );
return puppyAge;
}
public static void main(String []args) {
/*Object creation*/
Puppy myPuppy = new Puppy( "tommy" );
/*Call class method to set puppy's age*/
myPuppy.setAge( 2 );
/*Call another class method to get puppy's age*/
myPuppy.getAge( );
/*You can access instance variable as follows as well*/
System.out.println("Variable Value :" + myPuppy.puppyAge );
}
}上記のプログラムをコンパイルして実行すると、次の結果が生成されます-
出力
Name chosen is :tommy
Puppy's age is :2
Variable Value :2ソースファイル宣言規則
このセクションの最後の部分として、ソースファイルの宣言ルールを見てみましょう。 これらのルールは、ソースファイルでクラス、_import_ステートメント、および_package_ステートメントを宣言するときに不可欠です。
- ソースファイルごとにパブリッククラスは1つだけ存在できます。
- ソースファイルには、複数の非パブリッククラスを含めることができます。
- パブリッククラス名は、ソースファイルの名前である必要があり、最後に .java が追加されます。 たとえば、クラス名は_public class Employee \ {} _で、ソースファイルはEmployee.javaである必要があります。
- クラスがパッケージ内で定義されている場合、パッケージステートメントはソースファイルの最初のステートメントである必要があります。
- インポート文が存在する場合は、パッケージ文とクラス宣言の間に記述する必要があります。 パッケージ文がない場合は、インポート文をソースファイルの最初の行にする必要があります。
- インポートおよびパッケージステートメントは、ソースファイルに存在するすべてのクラスを意味します。 ソースファイルの異なるクラスに異なるインポートおよび/またはパッケージステートメントを宣言することはできません。
クラスには複数のアクセスレベルがあり、さまざまなタイプのクラスがあります。抽象クラス、最終クラスなど これらすべてについては、アクセス修飾子の章で説明します。
上記のタイプのクラスとは別に、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クラスを実行するには、メインメソッドとオブジェクトを作成する必要があります。 これらのタスク用に個別のクラスを作成します。
以下は_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-コンストラクター
コンストラクターは、作成時にオブジェクトを初期化します。 クラスと同じ名前を持ち、構文的にはメソッドに似ています。 ただし、コンストラクターには明示的な戻り値の型はありません。
通常、コンストラクターを使用して、クラスによって定義されたインスタンス変数に初期値を与えるか、完全な形式のオブジェクトを作成するために必要な他の起動手順を実行します。
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 20Java-基本データ型
変数は、値を保存するために予約されたメモリの場所に他なりません。 これは、変数を作成するときに、メモリ内にスペースを確保することを意味します。
変数のデータ型に基づいて、オペレーティングシステムはメモリを割り当て、予約メモリに保存できるものを決定します。 したがって、異なるデータ型を変数に割り当てることにより、これらの変数に整数、小数、または文字を格納できます。
Javaで利用可能な2つのデータ型があります-
- プリミティブデータ型
- 参照/オブジェクトのデータ型
プリミティブデータ型
Javaでサポートされる8つのプリミティブデータ型があります。 プリミティブデータ型は、言語によって事前定義され、キーワードによって名前が付けられます。 ここで、8つのプリミティブデータ型を詳細に調べてみましょう。
byte
- バイトデータ型は、8ビットの符号付き2の補数整数です
- 最小値は-128（-2 ^ 7）です
- 最大値は127（両端を含む）（2 ^ 7 -1）
- デフォルト値は0
- バイトは整数の4倍小さいため、バイトデータ型は大きな配列のスペースを節約するために使用されます。
- 例：バイトa = 100、バイトb = -50
ショート
- 短いデータ型は、16ビットの符号付き2の補数整数です
- 最小値は-32,768（-2 ^ 15）
- 最大値は32,767（両端を含む）（2 ^ 15 -1）です
- 短いデータ型を使用して、メモリをバイトデータ型として保存することもできます。 shortは整数の2倍小さい
- デフォルト値は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
long
- longデータ型は、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ビットIEEE 754浮動小数点です
- Floatは主に、浮動小数点数の大きな配列でメモリを節約するために使用されます
- デフォルト値は0.0f
- 浮動小数点データ型は、通貨などの正確な値には使用されません
- 例：float f1 = 234.5f
ダブル
- doubleデータ型は、倍精度64ビットIEEE 754浮動小数点です
- このデータ型は通常、10進数値のデフォルトのデータ型として使用されます。通常はデフォルトの選択です
- doubleデータ型は、通貨などの正確な値には使用しないでください
- デフォルト値は0.0d
- 例：double d1 = 123.4
ブール値
- ブールデータ型は1ビットの情報を表します
- 可能な値は2つのみです：trueおよびfalse
- このデータ型は、true/false条件を追跡する単純なフラグに使用されます
- デフォルト値はfalseです
- 例：boolean one = true
char
- charデータ型は単一の16ビットUnicode文字です
- 最小値は '\ u0000'（または0）です
- 最大値は '\ uffff'（または65,535を含む）です
- 文字データ型は、任意の文字を格納するために使用されます
- 例：char letterA = 'A'
参照データ型
- 参照変数は、クラスの定義済みコンストラクターを使用して作成されます。 オブジェクトにアクセスするために使用されます。 これらの変数は、変更できない特定の型であると宣言されています。 たとえば、従業員、子犬など。
- クラスオブジェクトとさまざまなタイプの配列変数は、参照データ型に分類されます。
- 参照変数のデフォルト値はnullです。
- 参照変数を使用して、宣言された型または互換性のある型のオブジェクトを参照できます。
- 例：動物animal = 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リテラルの特別なエスケープシーケンスもほとんどサポートされていません。 彼らは-
| Notation | Character represented |
|---|---|
| \n | Newline (0x0a) |
| \r | Carriage return (0x0d) |
| \f | Formfeed (0x0c) |
| \b | Backspace (0x08) |
| \s | Space (0x20) |
| \t | tab |
| \" | Double quote |
| \' | Single quote |
| \\ | backslash |
| \ddd | Octal character (ddd) |
| \uxxxx | Hexadecimal UNICODE character (xxxx) |
次は何ですか？
この章では、さまざまなデータ型について説明しました。 次のトピックでは、さまざまな変数タイプとその使用法について説明します。 これにより、Javaクラス、インターフェースなどでそれらをどのように使用できるかがよく理解できます。
Java-変数タイプ
変数は、プログラムが操作できる名前付きストレージを提供します。 Javaの各変数には特定のタイプがあり、変数のメモリのサイズとレイアウトを決定します。そのメモリ内に保存できる値の範囲。変数に適用できる一連の操作。
すべての変数を使用する前に宣言する必要があります。 以下は、変数宣言の基本的な形式です-
data type variable [ = value][, variable [ = value] ...] ;ここで、_data type_はJavaのデータ型の1つであり、_variable_は変数の名前です。 指定されたタイプの複数の変数を宣言するには、コンマ区切りリストを使用できます。
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種類の変数があります-
- ローカル変数
- インスタンス変数
- クラス/静的変数
ローカル変数
- ローカル変数は、メソッド、コンストラクター、またはブロックで宣言されます。
- ローカル変数は、メソッド、コンストラクター、またはブロックに入ると作成され、メソッド、コンストラクター、またはブロックを出ると変数は破棄されます。
- ローカル変数にはアクセス修飾子を使用できません。
- ローカル変数は、宣言されたメソッド、コンストラクター、またはブロック内でのみ表示されます。
- ローカル変数は、内部的にスタックレベルで実装されます。
- ローカル変数にはデフォルト値がないため、最初に使用する前にローカル変数を宣言し、初期値を割り当てる必要があります。
例
ここで、_age_はローカル変数です。 これは_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_を呼び出してアクセスできます。
- クラス変数をpublic static finalとして宣言する場合、変数名（定数）はすべて大文字です。 静的変数がパブリックおよびファイナルでない場合、命名構文はインスタンス変数およびローカル変数と同じです。
例
import java.io.*;
public class Employee {
//salary variable is a private static variable
private static double salary;
//DEPARTMENT is a constant
public static final String DEPARTMENT = "Development ";
public static void main(String args[]) {
salary = 1000;
System.out.println(DEPARTMENT + "average salary:" + salary);
}
}これは、次の結果を生成します-
出力
Development average salary:1000注意-変数が外部クラスからアクセスされる場合、定数はEmployee.DEPARTMENTとしてアクセスされる必要があります
次は何ですか？
この章ではすでにアクセス修飾子（パブリックおよびプライベート）を使用しています。 次の章では、アクセス修飾子と非アクセス修飾子について詳しく説明します。
Java-修飾子タイプ
修飾子は、意味を変更するためにこれらの定義に追加するキーワードです。 Java言語には、以下を含む多種多様な修飾子があります-
- リンク：/java/java_access_modifiers [Java Access Modifiers]
- リンク：/java/java_nonaccess_modifiers [非アクセス修飾子]
修飾子を使用するには、クラス、メソッド、または変数の定義にそのキーワードを含めます。 次の例のように、修飾子はステートメントの残りの部分の前にあります。
例
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は、他の多くの機能を実現するために、多くの非アクセス修飾子を提供します。
- クラスのメソッドと変数を作成するための_static_修飾子。
- クラス、メソッド、変数の実装を確定するための_final_修飾子。
- 抽象クラスとメソッドを作成するための_abstract_修飾子。
- スレッドに使用される_synchronized_および_volatile_修飾子。
次は何ですか？
次のセクションでは、Java言語で使用される基本演算子について説明します。 この章では、アプリケーション開発中にこれらの演算子を使用する方法の概要を説明します。
Java-基本的な演算子
Javaは、変数を操作するための豊富な演算子セットを提供します。 私たちはすべてのJava演算子を次のグループに分けることができます-
- 算術演算子
- 関係演算子
- ビット演算子
- 論理演算子
- 割り当て演算子
- その他の演算子
算術演算子
算術演算子は、代数で使用されるのと同じ方法で数式で使用されます。 次の表は、算術演算子を示しています-
整数変数Aが10を保持し、変数Bが20を保持すると仮定します-
リンク：/java/java_arithmatic_operators_examples [例を表示]
| Operator | Description | Example |
|---|---|---|
| PLUS (Addition) | Adds values on either side of the operator. | A PLUS B will give 30 |
| - (Subtraction) | Subtracts right-hand operand from left-hand operand. | A - B will give -10 |
| AST (Multiplication) | Multiplies values on either side of the operator. | A AST B will give 200 |
| /(Division) | Divides left-hand operand by right-hand operand. | B/A will give 2 |
| % (Modulus) | Divides left-hand operand by right-hand operand and returns remainder. | B % A will give 0 |
| PLUSPLUS (Increment) | Increases the value of operand by 1. | BPLUSPLUS gives 21 |
| — (Decrement) | Decreases the value of operand by 1. | B-- gives 19 |
関係演算子
Java言語でサポートされている関係演算子は次のとおりです。
変数Aが10を保持し、変数Bが20を保持すると仮定します-
リンク：/java/java_relational_operators_examples [例を表示]
| Operator | Description | Example |
|---|---|---|
| == (equal to) | Checks if the values of two operands are equal or not, if yes then condition becomes true. | (A == B) is not true. |
| != (not equal to) | Checks if the values of two operands are equal or not, if values are not equal then condition becomes true. | (A != B) is true. |
| > (greater than) | Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true. | (A > B) is not true. |
| < (less than) | Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true. | (A < B) is true. |
| >= (greater than or equal to) | Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true. | (A >= B) is not true. |
| ⇐ (less than or equal to) | Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true. | (A ⇐ B) is true. |
ビット演算子
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を保持すると仮定します-
リンク：/java/java_bitwise_operators_examples [例を表示]
[cols="^,,^",options="header",]
|===
|Operator |Description |Example |& (bitwise and) |Binary AND Operator copies a bit to the result if it exists in both operands. |(A & B) will give 12 which is 0000 1100 || (bitwise or) |Binary OR Operator copies a bit if it exists in either operand. |(A | B) will give 61 which is 0011 1101 |^ (bitwise XOR) |Binary XOR Operator copies the bit if it is set in one operand but not both. |(A ^ B) will give 49 which is 0011 0001 |~ (bitwise compliment) |Binary Ones Complement Operator is unary and has the effect of 'flipping' bits. |(~A ) will give -61 which is 1100 0011 in 2's complement form due to a signed binary number. |<< (left shift) |Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand. |A << 2 will give 240 which is 1111 0000 |>> (right shift) |Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand. |A >> 2 will give 15 which is 1111 |>>> (zero fill right shift) |Shift right zero fill operator. The left operands value is moved right by the number of bits specified by the right operand and shifted values are filled up with zeros. |A >>>2 will give 15 which is 0000 1111
|===
=== 論理演算子
次の表は、論理演算子を示しています-
ブール変数Aがtrueを保持し、変数Bがfalseを保持すると仮定します-
リンク：/java/java_logical_operators_examples [例を表示]
[cols="^,,^",options="header",]
|===
|Operator |Description |Example |&& (logical and) |Called Logical AND operator. If both the operands are non-zero, then the condition becomes true. |(A && B) is false ||| (logical or) |Called Logical OR Operator. If any of the two operands are non-zero, then the condition becomes true. |(A || B) is true |! (logical not) |Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. |!(A && B) is true
|===
=== 割り当て演算子
以下は、Java言語でサポートされている割り当て演算子です-
リンク：/java/java_assignment_operators_examples [例を表示]
[cols="^,,^",options="header",]
|===
|Operator |Description |Example |= |Simple assignment operator. Assigns values from right side operands to left side operand. |C = A + B will assign value of A + B into C |+= |Add AND assignment operator. It adds right operand to the left operand and assign the result to left operand. |C += A is equivalent to C = C + A |-= |Subtract AND assignment operator. It subtracts right operand from the left operand and assign the result to left operand. |C -= A is equivalent to C = C – A |*= |Multiply AND assignment operator. It multiplies right operand with the left operand and assign the result to left operand. |C *= A is equivalent to C = C * A |/= |Divide AND assignment operator. It divides left operand with the right operand and assign the result to left operand. |C/= A is equivalent to C = C/A |%= |Modulus AND assignment operator. It takes modulus using two operands and assign the result to left operand. |C %= A is equivalent to C = C % A |<<= |Left shift AND assignment operator. |C <<= 2 is same as C = C << 2 |>>= |Right shift AND assignment operator. |C >>= 2 is same as C = C >> 2 |&= |Bitwise AND assignment operator. |C &= 2 is same as C = C & 2 |^= |bitwise exclusive OR and assignment operator. |C ^= 2 is same as C = C ^ 2 ||= |bitwise inclusive OR and assignment operator. |C |= 2 is same as C = C | 2
|===
=== その他の演算子
Java言語でサポートされている他の演算子はほとんどありません。
==== 条件演算子（？ : )
条件演算子は、*三項演算子*とも呼ばれます。 この演算子は3つのオペランドで構成され、ブール式を評価するために使用されます。 オペレーターの目標は、変数に割り当てる値を決定することです。 演算子は次のように書かれています-
[source,result,notranslate]
----
variable x = (expression) ? value if true : value if false
----
以下は例です-
*例*
[source,prettyprint,notranslate]
----
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 );
}
}
----
これは、次の結果を生成します-
*出力*
[source,result,notranslate]
----
Value of b is : 30
Value of b is : 20
----
==== instanceof演算子
この演算子は、オブジェクト参照変数にのみ使用されます。 オペレーターは、オブジェクトが特定のタイプ（クラスタイプまたはインターフェースタイプ）であるかどうかをチェックします。 instanceof演算子は次のように記述されます-
[source,result,notranslate]
----
( Object reference variable ) instanceof (class/interface type)
----
演算子の左側の変数によって参照されるオブジェクトが右側のクラス/インターフェイスタイプのIS-Aチェックに合格した場合、結果はtrueになります。 以下は例です-
*例*
[source,prettyprint,notranslate]
----
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 );
}
}
----
これは、次の結果を生成します-
*出力*
[source,result,notranslate]
----
true
----
比較されるオブジェクトが右側の型と互換性のある割り当てである場合、この演算子は依然としてtrueを返します。 以下はもう一つの例です-
*例*
[source,prettyprint,notranslate]
----
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 );
}
}
----
これは、次の結果を生成します-
*出力*
[source,result,notranslate]
----
true
----
=== Javaオペレーターの優先順位
演算子の優先順位は、式内の用語のグループ化を決定します。 これは、式の評価方法に影響します。 特定の演算子は、他の演算子よりも優先順位が高くなっています。たとえば、乗算演算子は加算演算子よりも優先順位が高い-
たとえば、x = 7＆plus; 3＆ast; 2;ここでは、演算子＆ast;が20であるため、xは20ではなく13に割り当てられます＆plus;よりも優先順位が高いため、最初に3が乗算されます＆ast; 2から7に追加します。
ここでは、優先順位が最も高い演算子が表の上部に表示され、優先順位が最も低い演算子が下部に表示されます。 式内では、優先順位の高い演算子が最初に評価されます。
[cols=",,",options="header",]
|===
|Category |Operator |Associativity |Postfix |expression++ expression-- |Left to right |Unary |++expression –-expression +expression –expression ~ ! |Right to left |Multiplicative | */% |Left to right |Additive |+ - |Left to right |Shift |<< >> >>> |Left to right |Relational |< > <= >= instanceof |Left to right |Equality |== != |Left to right |Bitwise AND |& |Left to right |Bitwise XOR |^ |Left to right |Bitwise OR || |Left to right |Logical AND |&& |Left to right |Logical OR ||| |Left to right |Conditional |?: |Right to left |Assignment |= += -=* =/= %= ^= |= <<= >>= >>>= |Right to left
|===
=== 次は何ですか？
次の章では、Javaプログラミングのループ制御について説明します。 この章では、さまざまなタイプのループと、これらのループがJavaプログラム開発でどのように使用されるか、およびそれらがどのような目的で使用されるかについて説明します。Java-ループ制御
コードのブロックを数回実行する必要がある場合があります。 一般に、ステートメントは順番に実行されます。関数の最初のステートメントが最初に実行され、次に2番目のステートメントが実行されます。
プログラミング言語は、より複雑な実行パスを可能にするさまざまな制御構造を提供します。
- ループ*ステートメントは、ステートメントまたはステートメントのグループを複数回実行することを可能にし、ほとんどのプログラミング言語でのループステートメントの一般的な形式は次のとおりです-
Javaプログラミング言語は、ループ要件を処理するために次のタイプのループを提供します。 詳細を確認するには、次のリンクをクリックしてください。
| Sr.No. | Loop & Description |
|---|---|
| 1 |
特定の条件が真の間、ステートメントまたはステートメントのグループを繰り返します。 ループ本体を実行する前に条件をテストします。 |
| 2 |
一連のステートメントを複数回実行し、ループ変数を管理するコードを短縮します。 |
| 3 |
whileステートメントと似ていますが、ループ本体の最後で条件をテストします。 |
ループ制御ステートメント
ループ制御ステートメントは、通常のシーケンスから実行を変更します。 実行がスコープを離れると、そのスコープで作成されたすべての自動オブジェクトが破棄されます。
Javaは、次の制御ステートメントをサポートしています。 詳細を確認するには、次のリンクをクリックしてください。
| Sr.No. | Control Statement & Description |
|---|---|
| 1 |
|
| 2 |
ループがその本体の残りをスキップし、反復する前にその状態をすぐに再テストします。 |
Javaのforループの強化
Java 5以降、拡張forループが導入されました。 これは主に、配列を含む要素のコレクションを走査するために使用されます。
構文
拡張forループの構文は次のとおりです-
for(declaration : expression) {
//Statements
}- 宣言-新しく宣言されたブロック変数は、アクセスしている配列の要素と互換性のある型です。 変数は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プログラミングでの意思決定ステートメントについて学習します。
Java-意思決定
意思決定構造には、プログラムによって評価またはテストされる1つ以上の条件と、条件が真であると判定された場合に実行されるステートメント、およびオプションで、条件が判定された場合に実行される他のステートメントがあります偽りです。
以下は、ほとんどのプログラミング言語で見られる典型的な意思決定構造の一般的な形式です-
Javaプログラミング言語は、次のタイプの意思決定ステートメントを提供します。 詳細を確認するには、次のリンクをクリックしてください。
| Sr.No. | Statement & Description |
|---|---|
| 1 |
|
| 2 |
|
| 3 |
1つの if または else if ステートメントを別の if または else if ステートメント内で使用できます。 |
| 4 |
|
は？ ：オペレーター
条件演算子？ ：*前の章の *if … else ステートメントを置き換えるために使用できます。 それは次の一般的な形式を持っています-
Exp1 ? Exp2 : Exp3;Exp1、Exp2、およびExp3は式です。 コロンの使用と配置に注意してください。
式全体の値を決定するために、最初にexp1が評価されます。
- exp1の値がtrueの場合、Exp2の値は式全体の値になります。
- exp1の値がfalseの場合、Exp3が評価され、その値が式全体の値になります。
次は何ですか？
次の章では、java.langパッケージのNumberクラスとJava言語のサブクラスについて説明します。
プリミティブデータ型ではなく、これらのクラスのインスタンス化を使用するいくつかの状況と、Numbersを操作するときに知っておく必要のある書式設定、数学関数などのクラスを検討します。
Java-数値クラス
通常、Numbersを使用する場合、byte、int、long、doubleなどのプリミティブデータ型を使用します。
例
int i = 5000;
float gpa = 13.65;
double mask = 0xaf;ただし、開発では、プリミティブデータ型の代わりにオブジェクトを使用する必要がある状況に遭遇します。 これを実現するために、Javaには*ラッパークラス*が用意されています。
すべてのラッパークラス（整数、ロング、バイト、ダブル、フロート、ショート）は、抽象クラスのサブクラスです。
ラッパークラスのオブジェクトには、それぞれのプリミティブデータ型が含まれているか、ラップされています。 プリミティブデータ型をオブジェクトに変換することは*ボクシング*と呼ばれ、これはコンパイラによって処理されます。 したがって、ラッパークラスを使用している間は、Wrapperクラスのコンストラクターにプリミティブデータ型の値を渡すだけです。
また、Wrapperオブジェクトはプリミティブデータ型に変換され、このプロセスはボックス化解除と呼ばれます。 Number クラスはjava.langパッケージの一部です。
以下は、ボクシングとアンボクシングの例です-
例
public class Test {
public static void main(String args[]) {
Integer x = 5;//boxes int to an Integer object
x = x + 10; //unboxes the Integer to a int
System.out.println(x);
}
}これは、次の結果を生成します-
出力
15xに整数値が割り当てられている場合、xは整数オブジェクトであるため、コンパイラは整数をボックス化します。 後で、xがボックス化されていないため、整数として追加できます。
数値メソッド
以下は、Numberクラスのすべてのサブクラスが実装するインスタンスメソッドのリストです-
| Sr.No. | Method & Description |
|---|---|
| 1 |
this Numberオブジェクトの値をxxxデータ型に変換して返します。 |
| 2 |
this Numberオブジェクトを引数と比較します。 |
| 3 |
this numberオブジェクトが引数と等しいかどうかを決定します。 |
| 4 |
指定されたプリミティブの値を保持する整数オブジェクトを返します。 |
| 5 |
指定されたintまたはIntegerの値を表すStringオブジェクトを返します。 |
| 6 |
このメソッドは、特定の文字列のプリミティブデータ型を取得するために使用されます。 |
| 7 |
引数の絶対値を返します。 |
| 8 |
引数以上の最小の整数を返します。 doubleとして返されます。 |
| 9 |
引数以下の最大の整数を返します。 doubleとして返されます。 |
| 10 |
引数に値が最も近い整数を返します。 doubleとして返されます。 |
| 11 |
引数へのメソッドの戻り値の型で示される、最も近いlongまたはintを返します。 |
| 12 |
2つの引数のうち小さい方を返します。 |
| 13 |
2つの引数のうち大きい方を返します。 |
| 14 |
自然対数の底eを引数のべき乗で返します。 |
| 15 |
引数の自然対数を返します。 |
| 16 |
最初の引数の値を2番目の引数の累乗で返します。 |
| 17 |
引数の平方根を返します。 |
| 18 |
指定されたdouble値のサインを返します。 |
| 19 |
指定されたdouble値の余弦を返します。 |
| 20 |
指定されたdouble値のタンジェントを返します。 |
| 21 |
指定されたdouble値のアークサインを返します。 |
| 22 |
指定されたdouble値の逆余弦を返します。 |
| 23 |
指定されたdouble値のアークタンジェントを返します。 |
| 24 |
直交座標（x、y）を極座標（r、シータ）に変換し、シータを返します。 |
| 25 |
引数を度に変換します。 |
| 26 |
引数をラジアンに変換します。 |
| 27 |
乱数を返します。 |
次は何ですか？
次のセクションでは、JavaのCharacterクラスについて説明します。 Javaでオブジェクトの文字とプリミティブデータ型charを使用する方法を学習します。
Java-文字クラス
通常、文字を扱うときは、プリミティブデータ型charを使用します。
例
char ch = 'a';
//Unicode for uppercase Greek omega character
char uniChar = '\u039A';
//an array of chars
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };しかし、開発では、プリミティブデータ型の代わりにオブジェクトを使用する必要がある状況に遭遇します。 これを実現するために、Javaはプリミティブデータ型charのラッパークラス Character を提供します。
Characterクラスには、文字を操作するための便利なクラス（つまり静的）メソッドがいくつか用意されています。 あなたはCharacterコンストラクタでCharacterオブジェクトを作成することができます-
Character ch = new Character('a');Javaコンパイラーは、状況によってはCharacterオブジェクトも作成します。 たとえば、プリミティブなcharをオブジェクトが必要なメソッドに渡すと、コンパイラはcharをCharacterに自動的に変換します。 変換が逆の場合、この機能はオートボクシングまたはアンボクシングと呼ばれます。
例
//Here following primitive char 'a'
//is boxed into the Character object ch
Character ch = 'a';
//Here primitive 'x' is boxed for method test,
//return is unboxed to char 'c'
char c = test('x');エスケープシーケンス
バックスラッシュ（\）が前にある文字はエスケープシーケンスであり、コンパイラにとって特別な意味があります。
このチュートリアルではSystem.out.println（）ステートメントで改行文字（\ n）が頻繁に使用され、文字列が印刷された後に次の行に進みます。
次の表は、Javaエスケープシーケンスを示しています-
| Escape Sequence | Description |
|---|---|
| \t | Inserts a tab in the text at this point. |
| \b | Inserts a backspace in the text at this point. |
| \n | Inserts a newline in the text at this point. |
| \r | Inserts a carriage return in the text at this point. |
| \f | Inserts a form feed in the text at this point. |
| \' | Inserts a single quote character in the text at this point. |
| \" | Inserts a double quote character in the text at this point. |
| \\ | Inserts a backslash character in the text at this point. |
print文でエスケープシーケンスが検出されると、コンパイラはそれに応じて解釈します。
例
あなたが引用符の中に引用符を入れたい場合は、内部引用符でエスケープシーケンス、\ "を使用する必要があります-
public class Test {
public static void main(String args[]) {
System.out.println("She said \"Hello!\" to me.");
}
}これは、次の結果を生成します-
出力
She said "Hello!" to me.キャラクターメソッド
以下は、Characterクラスのすべてのサブクラスが実装する重要なインスタンスメソッドのリストです-
| Sr.No. | Method & Description |
|---|---|
| 1 |
指定されたchar値が文字かどうかを判別します。 |
| 2 |
指定されたchar値が数字かどうかを判別します。 |
| 3 |
指定されたchar値が空白かどうかを判別します。 |
| 4 |
指定されたchar値が大文字かどうかを判別します。 |
| 5 |
指定されたchar値が小文字かどうかを判別します。 |
| 6 |
指定されたchar値の大文字形式を返します。 |
| 7 |
指定されたchar値の小文字形式を返します。 |
| 8 |
指定された文字値、つまり1文字の文字列を表すStringオブジェクトを返します。 |
メソッドの完全なリストについては、java.lang.Character API仕様を参照してください。
次は何ですか？
次のセクションでは、JavaのStringクラスについて説明します。 文字列を効率的に宣言して使用する方法と、文字列クラスの重要なメソッドのいくつかを学習します。
Java-文字列クラス
Javaプログラミングで広く使用されている文字列は、一連の文字です。 Javaプログラミング言語では、文字列はオブジェクトとして扱われます。
Javaプラットフォームは、文字列を作成および操作するStringクラスを提供します。
文字列を作成する
文字列を作成する最も直接的な方法は、書くことです-
String greeting = "Hello world!";コード内で文字列リテラルが検出されるたびに、コンパイラはこの場合の値「Hello world！」でStringオブジェクトを作成します。
他のオブジェクトと同様に、新しいキーワードとコンストラクターを使用してStringオブジェクトを作成できます。 Stringクラスには11個のコンストラクターがあり、文字の配列などのさまざまなソースを使用して、ストリングの初期値を提供できます。
例
public class StringDemo {
public static void main(String args[]) {
char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };
String helloString = new String(helloArray);
System.out.println( helloString );
}
}これは、次の結果を生成します-
出力
hello.注-Stringクラスは不変であるため、一度作成されたStringオブジェクトは変更できません。 文字列に多くの変更を加える必要がある場合は、link：/java/java_string_buffer [String Buffer＆String Builder] Classesを使用する必要があります。
ストリングの長さ
オブジェクトに関する情報を取得するために使用されるメソッドは、*アクセサメソッド*と呼ばれます。 文字列で使用できる1つのアクセサメソッドはlength（）メソッドです。このメソッドは、文字列オブジェクトに含まれる文字数を返します。
次のプログラムは、* length（）*、メソッドStringクラスの例です。
例
public class StringDemo {
public static void main(String args[]) {
String palindrome = "Dot saw I was Tod";
int len = palindrome.length();
System.out.println( "String Length is : " + len );
}
}これは、次の結果を生成します-
出力
String Length is : 17文字列の連結
文字列クラスには、2つの文字列を連結するためのメソッドが含まれています-
string1.concat(string2);これは、最後にstring2が追加されたstring1である新しい文字列を返します。 次のように、文字列リテラルでconcat（）メソッドを使用することもできます-
"My name is ".concat("Zara");文字列は、一般的に＆plus;と連結されます。演算子-
"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のstatic format（）メソッドを使用すると、1回限りのprintステートメントではなく、再利用できるフォーマットされた文字列を作成できます。 たとえば、代わりに-
例
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クラスでサポートされているメソッドのリストです-
| Sr.No. | Method & Description |
|---|---|
| 1 |
指定されたインデックスにある文字を返します。 |
| 2 |
この文字列を別のオブジェクトと比較します。 |
| 3 |
int compareTo(String anotherString) 2つの文字列を辞書式に比較します。 |
| 4 |
int compareToIgnoreCase(String str) 大文字と小文字の違いを無視して、2つの文字列を辞書式に比較します。 |
| 5 |
指定された文字列をこの文字列の末尾に連結します。 |
| 6 |
boolean contentEquals(StringBuffer sb) このStringが指定されたStringBufferと同じ文字シーケンスを表す場合にのみtrueを返します。 |
| 7 |
static String copyValueOf(char[ data)] 指定された配列内の文字シーケンスを表す文字列を返します。 |
| 8 |
static String copyValueOf(char[ data, int offset, int count)] 指定された配列内の文字シーケンスを表す文字列を返します。 |
| 9 |
boolean endsWith(String suffix) この文字列が指定されたサフィックスで終わるかどうかをテストします。 |
| 10 |
boolean equals(Object anObject) この文字列を指定されたオブジェクトと比較します。 |
| 11 |
boolean equalsIgnoreCase(String anotherString) この文字列を別の文字列と比較し、大文字と小文字の区別を無視します。 |
| 12 |
プラットフォームのデフォルトの文字セットを使用してこの文字列をバイトのシーケンスにエンコードし、結果を新しいバイト配列に格納します。 |
| 13 |
byte[ getBytes(String charsetName)] 名前付き文字セットを使用してこの文字列をバイトのシーケンスにエンコードし、結果を新しいバイト配列に格納します。 |
| 14 |
void getChars(int srcBegin, int srcEnd, char[ dst, int dstBegin)] この文字列からコピー先の文字配列に文字をコピーします。 |
| 15 |
この文字列のハッシュコードを返します。 |
| 16 |
この文字列内で、指定された文字が最初に現れるインデックスを返します。 |
| 17 |
int indexOf(int ch, int fromIndex) この文字列内で指定された文字が最初に出現した位置のインデックスを返し、指定されたインデックスから検索を開始します。 |
| 18 |
この文字列内で、指定された部分文字列が最初に現れるインデックスを返します。 |
| 19 |
int indexOf(String str, int fromIndex) 指定されたインデックスで始まる、指定された部分文字列の最初の出現のこの文字列内のインデックスを返します。 |
| 20 |
文字列オブジェクトの正規表現を返します。 |
| 21 |
この文字列内で、指定された文字が最後に出現するインデックスを返します。 |
| 22 |
int lastIndexOf(int ch, int fromIndex) この文字列内で指定された文字の最後の出現のインデックスを返し、指定されたインデックスから逆方向に検索します。 |
| 23 |
この文字列内で、指定された部分文字列の右端の出現のインデックスを返します。 |
| 24 |
int lastIndexOf(String str, int fromIndex) この文字列内で、指定された部分文字列の最後の出現のインデックスを返します。指定されたインデックスから逆方向に検索します。 |
| 25 |
この文字列の長さを返します。 |
| 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 |
String replace(char oldChar, char newChar) この文字列内のすべてのoldCharをnewCharで置き換えた結果の新しい文字列を返します。 |
| 30 |
String replaceAll(String regex, String replacement 与えられた正規表現にマッチするこの文字列の各部分文字列を与えられた文字列に置き換えます。 |
| 31 |
String replaceFirst(String regex, String replacement) 指定された正規表現に一致するこの文字列の最初の部分文字列を指定された置換に置き換えます。 |
| 32 |
String[ split(String regex)] この文字列を、指定された正規表現の一致で分割します。 |
| 33 |
String[ split(String regex, int limit)] この文字列を、指定された正規表現の一致で分割します。 |
| 34 |
boolean startsWith(String prefix) この文字列が指定されたプレフィックスで始まるかどうかをテストします。 |
| 35 |
boolean startsWith(String prefix, int toffset) この文字列が、指定されたインデックスで始まる指定されたプレフィックスで始まるかどうかをテストします。 |
| 36 |
CharSequence subSequence(int beginIndex, int endIndex) このシーケンスのサブシーケンスである新しい文字シーケンスを返します。 |
| 37 |
String substring(int beginIndex) この文字列の部分文字列である新しい文字列を返します。 |
| 38 |
String substring(int beginIndex, int endIndex) この文字列の部分文字列である新しい文字列を返します。 |
| 39 |
char[ toCharArray()] この文字列を新しい文字配列に変換します。 |
| 40 |
デフォルトのロケールの規則を使用して、この文字列のすべての文字を小文字に変換します。 |
| 41 |
String toLowerCase(Locale locale) 指定されたロケールのルールを使用して、この文字列のすべての文字を小文字に変換します。 |
| 42 |
このオブジェクト（すでに文字列です！）自体が返されます。 |
| 43 |
デフォルトのロケールの規則を使用して、このストリング内のすべての文字を大文字に変換します。 |
| 44 |
String toUpperCase(Locale locale) 指定されたロケールのルールを使用して、この文字列のすべての文字を大文字に変換します。 |
| 45 |
文字列のコピーを返します。先頭と末尾の空白は省略されます。 |
| 46 |
static String valueOf(primitive data type x) 渡されたデータ型引数の文字列表現を返します。 |
Java-配列
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.注-スタイル dataType [] arrayRefVar が推奨されます。 スタイル dataType arrayRefVar [] は、C/C＆plus;＆plus;に由来します。言語であり、C/C＆plus;＆plus;に対応するために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.5foreachループ
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] + " ");
}
}配列を渡すことで呼び出すことができます。 たとえば、次のステートメントは、3、1、2、6、4、および2を表示するprintArrayメソッドを呼び出します-
例
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クラスには、配列のソートと検索、配列の比較、配列要素の入力のためのさまざまな静的メソッドが含まれています。 これらのメソッドは、すべてのプリミティブタイプに対してオーバーロードされます。
| Sr.No. | Method & Description |
|---|---|
| 1 |
public static int binarySearch(Object[] a, Object key) バイナリ検索アルゴリズムを使用して、指定されたオブジェクト（Object、Byte、Int、doubleなど）の指定された配列を検索します。 この呼び出しを行う前に、配列をソートする必要があります。 リストに含まれている場合、検索キーのインデックスを返します。それ以外の場合は、（–（挿入ポイント＆plus; 1））を返します。 |
| 2 |
public static boolean equals(long[] a, long[] a2) 指定された2つのlongの配列が互いに等しい場合、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-日付と時刻
Javaは、 java.util パッケージで利用可能な Date クラスを提供します。このクラスは、現在の日付と時刻をカプセル化します。
Dateクラスは、次の表に示す2つのコンストラクターをサポートします。
| Sr.No. | Constructor & Description |
|---|---|
| 1 |
Date( ) このコンストラクターは、現在の日付と時刻でオブジェクトを初期化します。 |
| 2 |
Date(long millisec) このコンストラクターは、1970年1月1日の午前0時から経過したミリ秒数に等しい引数を受け入れます。 |
日付クラスのメソッドは次のとおりです。
| Sr.No. | Method & Description |
|---|---|
| 1 |
boolean after(Date date) 呼び出したDateオブジェクトにdateで指定された日付よりも後の日付が含まれている場合はtrueを返し、それ以外の場合はfalseを返します。 |
| 2 |
boolean before(Date date) 呼び出したDateオブジェクトにdateで指定された日付よりも前の日付が含まれている場合はtrueを返し、それ以外の場合はfalseを返します。 |
| 3 |
Object clone( ) 呼び出し日付オブジェクトを複製します。 |
| 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文字はパターン文字として予約されており、次のように定義されています-
| Character | Description | Example |
|---|---|---|
| G | Era designator | AD |
| y | Year in four digits | 2001 |
| M | Month in year | July or 07 |
| d | Day in month | 10 |
| h | Hour in A.M./P.M. (1~12) | 12 |
| H | Hour in day (0~23) | 22 |
| m | Minute in hour | 30 |
| s | Second in minute | 55 |
| S | Millisecond | 234 |
| E | Day in week | Tuesday |
| D | Day in year | 360 |
| F | Day of week in month | 2 (second Wed. in July) |
| w | Week in year | 40 |
| W | Week in month | 1 |
| a | A.M./P.M. marker | PM |
| k | Hour in day (1~24) | 24 |
| K | Hour in A.M./P.M. (0~11) | 10 |
| z | Time zone | Eastern Standard Time |
| ' | Escape for text | Delimiter |
| " | Single quote | ` |
printfを使用した日付の書式設定
日付と時刻のフォーマットは、 printf メソッドを使用して非常に簡単に実行できます。 次のコードに示すように、 t で始まり、表の文字の1つで終わる2文字の形式を使用します。
例
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日付と時刻の変換文字
| Character | Description | Example |
|---|---|---|
| c | Complete date and time | Mon May 04 09:51:52 CDT 2009 |
| F | ISO 8601 date | 2004-02-09 |
| D | U.S. formatted date (month/day/year) | 02/09/2004 |
| T | 24-hour time | 18:05:19 |
| r | 12-hour time | 06:05:19 pm |
| R | 24-hour time, no seconds | 18:05 |
| Y | Four-digit year (with leading zeroes) | 2004 |
| y | Last two digits of the year (with leading zeroes) | 04 |
| C | First two digits of the year (with leading zeroes) | 20 |
| B | Full month name | February |
| b | Abbreviated month name | Feb |
| m | Two-digit month (with leading zeroes) | 02 |
| d | Two-digit day (with leading zeroes) | 03 |
| e | Two-digit day (without leading zeroes) | 9 |
| A | Full weekday name | Monday |
| a | Abbreviated weekday name | Mon |
| j | Three-digit day of year (with leading zeroes) | 069 |
| H | Two-digit hour (with leading zeroes), between 00 and 23 | 18 |
| k | Two-digit hour (without leading zeroes), between 0 and 23 | 18 |
| I | Two-digit hour (with leading zeroes), between 01 and 12 | 06 |
| l | Two-digit hour (without leading zeroes), between 1 and 12 | 6 |
| M | Two-digit minutes (with leading zeroes) | 05 |
| S | Two-digit seconds (with leading zeroes) | 19 |
| L | Three-digit milliseconds (with leading zeroes) | 047 |
| N | Nine-digit nanoseconds (with leading zeroes) | 047000000 |
| P | Uppercase morning or afternoon marker | PM |
| p | Lowercase morning or afternoon marker | pm |
| z | RFC 822 numeric offset from GMT | -0800 |
| Z | Time zone | PST |
| s | Seconds since 1970-01-01 00:00:00 GMT | 1078884319 |
| Q | Milliseconds since 1970-01-01 00:00:00 GMT | 1078884319047 |
日付と時刻に関連する他の便利なクラスがあります。 詳細については、Java Standardのドキュメントを参照できます。
文字列を日付に解析する
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 : 5993GregorianCalendarクラス
GregorianCalendarは、使い慣れた通常のグレゴリオ暦を実装するCalendarクラスの具体的な実装です。 このチュートリアルではCalendarクラスについては説明しませんでした。このための標準Javaドキュメントを参照できます。
Calendarの* getInstance（）*メソッドは、デフォルトのロケールとタイムゾーンの現在の日付と時刻で初期化されたGregorianCalendarを返します。 GregorianCalendarは、ADとBCの2つのフィールドを定義します。 これらは、グレゴリオ暦で定義された2つの時代を表しています。
GregorianCalendarオブジェクトのいくつかのコンストラクタもあります-
| Sr.No. | Constructor & Description |
|---|---|
| 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クラスによって提供されるいくつかの有用なサポートメソッドのリストです-
| Sr.No. | Method & Description |
|---|---|
| 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) 大きいフィールドを変更せずに、指定された時間フィールドで時間の単位を加算または減算（上/下）します。 |
| 19 |
void set(int field, int value) 指定された値で時間フィールドを設定します。 |
| 20 |
void set(int year, int month, int date) 年、月、および日付のフィールドの値を設定します。 |
| 21 |
void set(int year, int month, int date, int hour, int minute) 年、月、日付、時間、および分フィールドの値を設定します。 |
| 22 |
void set(int year, int month, int date, int hour, int minute, int 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 yearCalendarクラスで使用可能な定数の完全なリストについては、標準のJavaドキュメントを参照できます。
Java-正規表現
Javaは、正規表現とのパターンマッチングのためにjava.util.regexパッケージを提供します。 Javaの正規表現はPerlプログラミング言語に非常に似ており、非常に簡単に習得できます。
正規表現は、パターンに保持されている特殊な構文を使用して、他の文字列または文字列のセットを一致または検索するのに役立つ特殊な文字シーケンスです。 テキストおよびデータの検索、編集、または操作に使用できます。
java.util.regexパッケージは、主に次の3つのクラスで構成されています-
- パターンクラス-パターンオブジェクトは、正規表現のコンパイル済み表現です。 Patternクラスは、パブリックコンストラクターを提供しません。 パターンを作成するには、最初にパブリックstatic * compile（）*メソッドの1つを呼び出してから、Patternオブジェクトを返す必要があります。 これらのメソッドは、最初の引数として正規表現を受け入れます。
- * Matcherクラス*-Matcherオブジェクトは、パターンを解釈し、入力文字列に対して一致操作を実行するエンジンです。 Patternクラスと同様に、Matcherはパブリックコンストラクターを定義しません。 Matcherオブジェクトを取得するには、Patternオブジェクトで* matcher（）*メソッドを呼び出します。
- PatternSyntaxException -PatternSyntaxExceptionオブジェクトは、正規表現パターンの構文エラーを示す未チェックの例外です。
グループのキャプチャ
キャプチャグループは、複数の文字を単一のユニットとして扱う方法です。 グループ化する文字を括弧のセット内に配置することで作成されます。 たとえば、正規表現（dog）は、「d」、「o」、および「g」の文字を含む単一のグループを作成します。
キャプチャグループには、左から右に向かって括弧を数えることで番号が付けられます。 式（（A）（B（C）））では、例えば、4つのそのようなグループがあります-
- （（A）（B（C））））
- (A)
- （紀元前））
- ©
式に存在するグループの数を調べるには、マッチャーオブジェクトでgroupCountメソッドを呼び出します。 groupCountメソッドは、マッチャーのパターンに存在するキャプチャグループの数を示す int を返します。
式0を常に表す特別なグループgroup 0もあります。 このグループは、groupCountによって報告された合計には含まれません。
例
次の例は、指定された英数字文字列から数字列を見つける方法を示しています-
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");
}
}
}これは、次の結果を生成します-
- 出力 *
Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0正規表現の構文
これは、Javaで使用可能なすべての正規表現メタ文字構文をリストした表です-
| Subexpression | Matches |
|---|---|
| ^ | Matches the beginning of the line. |
| $ | Matches the end of the line. |
| . | Matches any single character except newline. Using* m* option allows it to match the newline as well. |
| […] | Matches any single character in brackets. |
| [^…] | 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. |
| rePLUS | 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 |
マッチャークラスのメソッド
ここに便利なインスタンスメソッドのリストがあります-
インデックスメソッド
インデックスメソッドは、入力文字列で一致が見つかった場所を正確に示す便利なインデックス値を提供します-
| Sr.No. | Method & Description |
|---|---|
| 1 |
前のマッチの開始インデックスを返します。 |
| 2 |
public int start(int group) 前の一致操作中に特定のグループによってキャプチャされたサブシーケンスの開始インデックスを返します。 |
| 3 |
public int end() 最後の文字が一致した後のオフセットを返します。 |
| 4 |
public int end(int group) 前の一致操作中に特定のグループによってキャプチャされたサブシーケンスの最後の文字の後のオフセットを返します。 |
研究方法
研究方法は、入力文字列を確認し、パターンが見つかったかどうかを示すブール値を返します-
| Sr.No. | Method & Description |
|---|---|
| 1 |
public boolean lookingAt() 領域の先頭から開始して、パターンに対して入力シーケンスを一致させようとします。 |
| 2 |
public boolean find() パターンに一致する入力シーケンスの次のサブシーケンスを見つけようとします。 |
| 3 |
public boolean find(int start) このマッチャーをリセットし、指定されたインデックスから開始して、パターンに一致する入力シーケンスの次のサブシーケンスを見つけようとします。 |
| 4 |
public boolean matches() 領域全体をパターンと一致させようとします。 |
交換方法
置換方法は、入力文字列内のテキストを置換するための便利な方法です-
| Sr.No. | Method & Description |
|---|---|
| 1 |
public Matcher appendReplacement(StringBuffer sb, String replacement) 非終端追加および置換ステップを実装します。 |
| 2 |
public StringBuffer appendTail(StringBuffer sb) ターミナルの追加および交換手順を実装します。 |
| 3 |
public String replaceAll(String replacement) パターンに一致する入力シーケンスのすべてのサブシーケンスを、指定された置換文字列に置き換えます。 |
| 4 |
public String replaceFirst(String replacement) パターンに一致する入力シーケンスの最初のサブシーケンスを、指定された置換文字列に置き換えます。 |
| 5 |
public static String quoteReplacement(String s) 指定された文字列のリテラル置換文字列を返します。 このメソッドは、MatcherクラスのappendReplacementメソッドでリテラル置換 s として機能するストリングを生成します。 |
開始および終了メソッド
以下は、単語「cat」が入力文字列に出現する回数をカウントする例です-
例
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());
}
}
}これは、次の結果を生成します-
出力
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この例では、単語の境界を使用して、文字 "c" "a" "t"が長い単語の単なる部分文字列ではないことを確認できます。 また、入力文字列のどこで一致したかに関するいくつかの有用な情報も提供します。
startメソッドは、前の一致操作中に特定のグループによってキャプチャされたサブシーケンスの開始インデックスを返し、終了は一致した最後の文字のインデックスに1を加えたものを返します。
マッチとlookingAtメソッド
matchesメソッドとlookingAtメソッドは両方とも、入力シーケンスをパターンと一致させようとします。 しかし、違いは、一致では入力シーケンス全体が一致する必要があるのに対して、lookingAtでは一致しないことです。
どちらの方法も常に入力文字列の先頭から始まります。 ここに機能を説明する例があります-
例
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());
}
}これは、次の結果を生成します-
出力
Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): falsereplaceFirstおよびreplaceAllメソッド
replaceFirstメソッドとreplaceAllメソッドは、特定の正規表現に一致するテキストを置き換えます。 名前が示すように、replaceFirstは最初の出現を置換し、replaceAllはすべての出現を置換します。
ここに機能を説明する例があります-
例
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);
}
}これは、次の結果を生成します-
出力
The cat says meow. All cats say meow.appendReplacementおよびappendTailメソッド
Matcherクラスは、テキスト置換のためのappendReplacementおよびappendTailメソッドも提供します。
ここに機能を説明する例があります-
例
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());
}
}これは、次の結果を生成します-
- 出力 *
-foo-foo-foo-PatternSyntaxExceptionクラスメソッド
PatternSyntaxExceptionは、正規表現パターンの構文エラーを示す未チェックの例外です。 PatternSyntaxExceptionクラスは、次のメソッドを提供して、何がうまくいかなかったかを判断するのに役立ちます-
| Sr.No. | Method & Description |
|---|---|
| 1 |
エラーの説明を取得します。 |
| 2 |
public int getIndex() エラーインデックスを取得します。 |
| 3 |
public String getPattern() エラーのある正規表現パターンを取得します。 |
| 4 |
public String getMessage() 構文エラーとそのインデックスの説明、エラーのある正規表現パターン、およびパターン内のエラーインデックスの視覚的表示を含む複数行の文字列を返します。 |
Java-メソッド
Javaメソッドは、操作を実行するためにグループ化されたステートメントのコレクションです。 たとえば、System.out。* println（）*メソッドを呼び出すと、システムは実際にいくつかのステートメントを実行して、コンソールにメッセージを表示します。
ここでは、戻り値を使用してまたは使用せずに独自のメソッドを作成し、パラメーターを使用してまたは使用せずにメソッドを呼び出し、プログラム設計にメソッド抽象化を適用する方法を学習します。
作成方法
メソッドの構文を説明するために次の例を検討してください-
構文
public static int methodName(int a, int b) {
//body
}ここに、
- public static -修飾子
- int -戻りタイプ
- methodName -メソッドの名前
- a、b -仮パラメータ
- int a、int b -パラメーターのリスト
メソッド定義は、メソッドヘッダーとメソッド本体で構成されます。 同じことは、次の構文に示されています-
構文
modifier returnType nameOfMethod (Parameter List) {
//method body
}上記の構文には以下が含まれます-
- 修飾子-それはメソッドのアクセスタイプを定義し、使用するオプションです。
- returnType -メソッドは値を返す場合があります。
- nameOfMethod -これはメソッド名です。 メソッドシグネチャは、メソッド名とパラメーターリストで構成されます。
- パラメータリスト-パラメータのリスト、それはメソッドのパラメータのタイプ、順序、および数です。 これらはオプションであり、メソッドにはパラメータが含まれない場合があります。
- method body -メソッド本体は、メソッドがステートメントに対して行うことを定義します。
例
上記の* min（）*というメソッドのソースコードを次に示します。 このメソッドは、num1とnum2の2つのパラメータを取り、2つの間の最大値を返します-
/* *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;
}メソッド呼び出し
メソッドを使用するには、メソッドを呼び出す必要があります。 メソッドが呼び出される方法は2つあります。つまり、メソッドは値を返すか、何も返さない（戻り値なし）
メソッド呼び出しのプロセスは簡単です。 プログラムがメソッドを呼び出すと、プログラム制御は呼び出されたメソッドに転送されます。 この呼び出されたメソッドは、次の2つの条件で制御を呼び出し元に返します。
- returnステートメントが実行されます。
- メソッドを閉じて中括弧を終了します。
voidを返すメソッドは、ステートメントの呼び出しと見なされます。 例を考えてみましょう-
System.out.println("This is finddevguides.com!");値を返すメソッドは、次の例で理解することができます-
int result = sum(6, 9);以下は、メソッドを定義する方法とそれを呼び出す方法を示すための例です-
例
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;
}
}これは、次の結果を生成します-
出力
Minimum value = 6voidキーワード
voidキーワードを使用すると、値を返さないメソッドを作成できます。 ここで、次の例では、voidメソッド_methodRankPoints_を検討しています。 このメソッドは値を返さないvoidメソッドです。 voidメソッドの呼び出しはステートメントでなければなりません。 _methodRankPoints（255.7）; _。 次の例に示すように、セミコロンで終わるJavaステートメントです。
例
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");
}
}
}これは、次の結果を生成します-
出力
Rank:A1値でパラメーターを渡す
呼び出しプロセスの下で作業している間、引数が渡されます。 これらは、メソッド仕様のそれぞれのパラメーターと同じ順序でなければなりません。 パラメータは、値または参照によって渡すことができます。
パラメータを値で渡すとは、パラメータを使用してメソッドを呼び出すことを意味します。 これにより、引数の値がパラメーターに渡されます。
例
次のプログラムは、値によってパラメーターを渡す例を示しています。 引数の値は、メソッド呼び出し後も同じままです。
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);
}
}これは、次の結果を生成します-
出力
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メソッドのオーバーロード
クラスに同じ名前でパラメーターが異なる2つ以上のメソッドがある場合、メソッドのオーバーロードと呼ばれます。 オーバーライドとは異なります。 オーバーライドでは、メソッドは同じメソッド名、タイプ、パラメーター数などを持ちます。
整数型の最小数を見つけるための前述の例を考えてみましょう。 もし、double型の最小数を見つけたいとしましょう。 次に、オーバーロードの概念を導入して、同じ名前で異なるパラメーターを持つ2つ以上のメソッドを作成します。
次の例は同じを説明します-
例
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;
}
}これは、次の結果を生成します-
出力
Minimum Value = 6
Minimum Value = 7.3メソッドをオーバーロードすると、プログラムが読み取り可能になります。 ここでは、2つのメソッドが同じ名前で、パラメーターが異なります。 整数型と倍精度型の最小数が結果です。
コマンドライン引数の使用
プログラムを実行するときに、プログラムに情報を渡したい場合があります。 これは、コマンドライン引数をmain（）に渡すことで実現されます。
コマンドライン引数は、実行時にコマンドラインでプログラムの名前のすぐ後に続く情報です。 Javaプログラム内のコマンドライン引数にアクセスするのは非常に簡単です。 これらは、main（）に渡される文字列配列に文字列として保存されます。
例
次のプログラムは、それが呼び出されるすべてのコマンドライン引数を表示します-
public class CommandLine {
public static void main(String args[]) {
for(int i = 0; i<args.length; i++) {
System.out.println("args[" + i + "]: " + args[i]);
}
}
}ここに示すようにこのプログラムを実行してみてください-
$java CommandLine this is a command line 200 -100これは、次の結果を生成します-
出力
args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100thisキーワード
*this* は、インスタンスメソッドまたはコンストラクターで、現在のクラスのオブジェクトへの参照として使用されるJavaのキーワードです。 _this_を使用すると、コンストラクター、変数、メソッドなどのクラスのメンバーを参照できます。注-キーワード_this_は、インスタンスメソッドまたはコンストラクタ内でのみ使用されます
一般的に、キーワード_this_はに使用されます-
- コンストラクターまたはメソッド内で同じ名前のインスタンス変数をローカル変数と区別します。
class Student {
int age;
Student(int age) {
this.age = age;
}
}- クラス内の別のタイプのコンストラクター（パラメーター化されたコンストラクターまたはデフォルト）を呼び出します。 これは、明示的なコンストラクター呼び出しとして知られています。
class Student {
int age
Student() {
this(20);
}
Student(int age) {
this.age = age;
}
}例
_this_キーワードを使用してクラスのメンバーにアクセスする例を次に示します。 次のプログラムをコピーして、 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 finddevguides");
}
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 parametrized constructor
This_Example obj2 = new This_Example(30);
//Invoking the print method again
obj2.print();
}
}これは、次の結果を生成します-
出力
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 finddevguides
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 finddevguides変数引数（var-args）
JDK 1.5では、同じタイプの可変数の引数をメソッドに渡すことができます。 メソッド内のパラメータは次のように宣言されています-
typeName... parameterNameメソッド宣言では、タイプの後に省略記号（…）を指定します。 1つのメソッドで指定できる可変長パラメーターは1つだけであり、このパラメーターは最後のパラメーターでなければなりません。 通常のパラメーターは、それに先行する必要があります。
例
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);
}
}これは、次の結果を生成します-
出力
The max value is 56.5
The max value is 3.0finalize（）メソッド
ガベージコレクターによるオブジェクトの最終的な破壊の直前に呼び出されるメソッドを定義することが可能です。 このメソッドは* finalize（）*と呼ばれ、オブジェクトが正常に終了することを保証するために使用できます。
たとえば、finalize（）を使用して、そのオブジェクトが所有している開いているファイルを確実に閉じます。
クラスにファイナライザを追加するには、finalize（）メソッドを定義するだけです。 Javaランタイムは、そのクラスのオブジェクトをリサイクルしようとするたびに、そのメソッドを呼び出します。
finalize（）メソッド内で、オブジェクトを破棄する前に実行する必要があるアクションを指定します。
finalize（）メソッドには、この一般的な形式があります-
protected void finalize( ) {
//finalization code here
}ここで、キーワードprotectedは、クラスの外部で定義されたコードによるfinalize（）へのアクセスを防ぐ指定子です。
これは、いつ、いつfinalize（）が実行されるかを知ることができないことを意味します。 たとえば、ガベージコレクションが発生する前にプログラムが終了した場合、finalize（）は実行されません。
Java-ファイルとI/O
java.ioパッケージには、Javaで入出力（I/O）を実行する必要がある可能性のあるほぼすべてのクラスが含まれています。 これらのストリームはすべて、入力ソースと出力宛先を表します。 java.ioパッケージのストリームは、プリミティブ、オブジェクト、ローカライズされた文字など、多くのデータをサポートしています。
ストリーム
ストリームは、データのシーケンスとして定義できます。 ストリームには2種類あります-
- InPutStream -InputStreamは、ソースからデータを読み取るために使用されます。
- OutPutStream -OutputStreamは、宛先にデータを書き込むために使用されます。
Javaは、ファイルとネットワークに関連するI/Oを強力かつ柔軟にサポートしますが、このチュートリアルでは、ストリームとI/Oに関連する非常に基本的な機能について説明します。 私たちは最も一般的に使用される例を1つずつ見ていきます-
バイトストリーム
Javaバイトストリームは、8ビットバイトの入出力を実行するために使用されます。 バイトストリームに関連するクラスは多数ありますが、最も頻繁に使用されるクラスは FileInputStream および FileOutputStream です。 以下は、これら2つのクラスを使用して入力ファイルを出力ファイルにコピーする例です-
例
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つのクラスを使用して、入力ファイル（ユニコード文字を含む）を出力ファイルにコピーします-
例
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＆plus;＆plus;を知っている場合プログラミング言語の場合、3つの標準デバイスSTDIN、STDOUT、およびSTDERRに注意する必要があります。 同様に、Javaは次の3つの標準ストリームを提供します-
- 標準入力-これはユーザーのプログラムにデータを供給するために使用され、通常キーボードは標準入力ストリームとして使用され、 System.in として表されます。
- 標準出力-これは、ユーザーのプログラムによって生成されたデータを出力するために使用され、通常はコンピューター画面が標準出力ストリームに使用され、 System.out として表されます。
- 標準エラー-これは、ユーザーのプログラムによって生成されたエラーデータを出力するために使用され、通常はコンピューター画面が標準エラーストリームに使用され、 System.err として表されます。
以下は、ユーザーが「q」を入力するまで標準入力ストリームを読み取るために InputStreamReader を作成する単純なプログラムです-
例
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_オブジェクトを手に入れると、ストリームの読み取りやストリームに対する他の操作に使用できるヘルパーメソッドのリストがあります。
| Sr.No. | Method & Description |
|---|---|
| 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を返します。 |
利用可能な他の重要な入力ストリームがあります。詳細については、次のリンクを参照できます-
- リンク：/java/java_bytearrayinputstream [ByteArrayInputStream] *リンク：/java/java_datainputstream [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_オブジェクトを手に入れると、ヘルパーメソッドのリストが表示されます。このメソッドを使用して、ストリームへの書き込みや、ストリームに対する他の操作を実行できます。
| Sr.No. | Method & Description |
|---|---|
| 1 |
このメソッドは、ファイル出力ストリームを閉じます。 ファイルに関連付けられているシステムリソースを解放します。 IOExceptionをスローします。 |
| 2 |
protected void finalize()throws IOException \{} このメソッドは、ファイルへの接続をクリーンアップします。 このストリームへの参照がなくなったときに、このファイル出力ストリームのcloseメソッドが呼び出されるようにします。 IOExceptionをスローします。 |
| 3 |
public void write(int w)throws IOException\{} このメソッドは、指定されたバイトを出力ストリームに書き込みます。 |
| 4 |
public void write(byte[] w) 言及されたバイト配列からw.lengthバイトをOutputStreamに書き込みます。 |
利用可能な他の重要な出力ストリームがあります。詳細については、次のリンクを参照できます-
- リンク：/java/java_bytearrayoutputstream [ByteArrayOutputStream]
- リンク：/java/java_dataoutputstream [DataOutputStream]
例
以下は、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を作成し、指定された数値をバイナリ形式で書き込みます。 同じことが、標準出力画面の出力になります。
ファイルナビゲーションとI/O
ファイルナビゲーションとI/Oの基本を知るために通過する他のクラスがいくつかあります。
- リンク：/java/java_file_class [ファイルクラス]
- リンク：/java/java_filereader_class [FileReader Class] *リンク：/java/java_filewriter_class [FileWriter Class]
Javaのディレクトリ
ディレクトリは、他のファイルとディレクトリのリストを含むことができるファイルです。* File *オブジェクトを使用してディレクトリを作成し、ディレクトリで使用可能なファイルを一覧表示します。 詳細については、Fileオブジェクトで呼び出すことができるすべてのメソッドと、ディレクトリに関連するメソッドのリストを確認してください。
ディレクトリの作成
ディレクトリを作成するために使用できる2つの便利な*ファイル*ユーティリティメソッドがあります-
- * mkdir（）*メソッドはディレクトリを作成し、成功するとtrueを返し、失敗するとfalseを返します。 失敗は、Fileオブジェクトで指定されたパスが既に存在するか、パス全体がまだ存在しないためにディレクトリを作成できないことを示します。
- * mkdirs（）*メソッドは、ディレクトリとディレクトリのすべての親の両方を作成します。
次の例では、「/tmp/user/java/bin」ディレクトリを作成します-
例
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」を作成します。
注-Javaは、慣例に従って、UNIXおよびWindows上のパス区切り文字を自動的に処理します。 JavaのWindowsバージョンでスラッシュ（/）を使用する場合、パスは引き続き正しく解決されます。
ディレクトリのリスト
*File* オブジェクトが提供する* list（）*メソッドを使用して、次のようにディレクトリで使用可能なすべてのファイルとディレクトリをリストダウンできます-例
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 ディレクトリで使用可能なディレクトリとファイルに基づいて次の結果が生成されます-
出力
test1.txt
test2.txt
ReadDir.java
ReadDir.classJava-例外
例外（または例外的なイベント）は、プログラムの実行中に発生する問題です。 *例外*が発生すると、プログラムの通常のフローが中断され、プログラム/アプリケーションが異常終了します。これは推奨されません。したがって、これらの例外は処理されます。
例外は、さまざまな理由で発生する可能性があります。 以下は、例外が発生するいくつかのシナリオです。
- ユーザーが無効なデータを入力しました。
- 開く必要があるファイルが見つかりません。
- 通信の途中でネットワーク接続が失われたか、JVMのメモリが不足しています。
これらの例外には、ユーザーエラーが原因の場合もあれば、プログラマーエラーが原因の場合もあります。
これらに基づいて、3つのカテゴリの例外があります。 Javaで例外処理がどのように機能するかを知るには、それらを理解する必要があります。
- チェック済み例外-チェック済み例外は、コンパイル時にコンパイラによってチェック（通知）される例外です。これらはコンパイル時例外とも呼ばれます。 これらの例外を単に無視することはできません。プログラマはこれらの例外を処理（処理）する必要があります。
たとえば、プログラムで 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注意-FileReaderクラスの* read（）および close（）*メソッドはIOExceptionをスローするため、コンパイラーはFileNotFoundExceptionとともにIOExceptionを処理するよう通知することを確認できます。
- 未チェックの例外-未チェックの例外は、実行時に発生する例外です。 これらは、*ランタイム例外*とも呼ばれます。 これには、論理エラーやAPIの不適切な使用などのプログラミングのバグが含まれます。 ランタイム例外はコンパイル時に無視されます。
たとえば、プログラムでサイズ5の配列を宣言し、配列の6 ^ th ^要素を呼び出そうとすると、_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)- エラー-これらは例外ではなく、ユーザーまたはプログラマーの制御を超えて発生する問題です。 通常、エラーについては何も実行できないため、コード内のエラーは無視されます。 たとえば、スタックオーバーフローが発生すると、エラーが発生します。 また、コンパイル時には無視されます。
例外階層
すべての例外クラスは、java.lang.Exceptionクラスのサブタイプです。 例外クラスは、Throwableクラスのサブクラスです。 例外クラス以外に、Throwableクラスから派生したErrorという別のサブクラスがあります。
エラーは、重大な障害が発生した場合に発生する異常な状態であり、Javaプログラムでは処理されません。 エラーは、ランタイム環境によって生成されたエラーを示すために生成されます。 例：JVMはメモリ不足です。 通常、プログラムはエラーから回復できません。
Exceptionクラスには、IOExceptionクラスとRuntimeExceptionクラスの2つの主要なサブクラスがあります。
以下は、最も一般的なチェック済みおよび未チェックのリンクのリストです：/java/java_builtin_exceptions [Javaの組み込み例外]。
例外メソッド
以下は、Throwableクラスで使用できる重要なメソッドのリストです。
| Sr.No. | Method & Description |
|---|---|
| 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ステートメントには、キャッチしようとしている例外のタイプの宣言が含まれます。 保護されたコードで例外が発生した場合、tryに続くcatchブロックがチェックされます。 発生した例外のタイプがcatchブロックにリストされている場合、引数がメソッドパラメーターに渡されるのと同じように、例外はcatchブロックに渡されます。
例
以下は、2つの要素で宣言された配列です。 次に、コードは、例外をスローする配列の3 ^ rd ^要素にアクセスしようとします。
//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つのcatchブロックを示していますが、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では、1つの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
}最後のブロック
finallyブロックは、tryブロックまたはcatchブロックの後に続きます。 例外の発生に関係なく、コードの最終ブロックは常に実行されます。
finallyブロックを使用すると、保護されたコードで何が起こっても、実行するクリーンアップタイプのステートメントを実行できます。
finallyブロックは、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ブロックの間にコードを含めることはできません。
try-with-resources
通常、ストリーム、接続などのリソースを使用する場合 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で導入された新しい例外処理メカニズムであり、try catchブロック内で使用されているリソースを自動的に閉じます。このステートメントを使用するには、括弧内で必要なリソースを宣言するだけでよく、作成されたリソースはブロックの終わりで自動的に閉じられます。 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ブロックの開始直前にインスタンス化されます。
- tryブロックで宣言されたリソースは、暗黙的にfinalとして宣言されます。
ユーザー定義の例外
Javaで独自の例外を作成できます。 独自の例外クラスを作成するときは、次の点に注意してください-
- すべての例外はThrowableの子でなければなりません。
- ハンドルルールまたは宣言ルールによって自動的に適用されるチェック済み例外を作成する場合は、Exceptionクラスを拡張する必要があります。
- ランタイム例外を作成する場合は、RuntimeExceptionクラスを拡張する必要があります。
以下のように独自の例外クラスを定義できます-
class MyException extends Exception {
}定義済みの Exception クラスを拡張して、独自の例外を作成する必要があります。 これらはチェック例外と見なされます。 次の InsufficientFundsException クラスは、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例外*-これらは、JVMによって排他的または論理的にスローされる例外/エラーです。 例：NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException。
- プログラムの例外-これらの例外は、アプリケーションまたはAPIプログラマーによって明示的にスローされます。 例：IllegalArgumentException、IllegalStateException。
Java-内部クラス
この章では、Javaの内部クラスについて説明します。
入れ子クラス
Javaでは、メソッドと同様に、クラスの変数もそのメンバーとして別のクラスを持つことができます。 Javaでは、別のクラス内にクラスを作成できます。 内部に記述されたクラスは*ネストされたクラス*と呼ばれ、内部クラスを保持するクラスは*外部クラス*と呼ばれます。
構文
ネストされたクラスを記述する構文は次のとおりです。 ここで、クラス Outer_Demo は外部クラスであり、クラス Inner_Demo はネストされたクラスです。
class Outer_Demo {
class Inner_Demo {
}
}ネストされたクラスは2つのタイプに分けられます-
- 非静的ネストクラス-これらはクラスの非静的メンバーです。
- 静的ネストクラス-これらはクラスの静的メンバーです。
内部クラス（非静的なネストされたクラス）
内部クラスは、Javaのセキュリティメカニズムです。 クラスをアクセス修飾子 private に関連付けることはできませんが、クラスを他のクラスのメンバーとして持っている場合、内部クラスをプライベートにすることができます。 また、これはクラスのプライベートメンバーへのアクセスにも使用されます。
内部クラスには、定義方法と場所に応じて3つのタイプがあります。 彼らは-
- 内部クラス
- メソッドローカル内部クラス
- 匿名の内部クラス
内部クラス
内部クラスの作成は非常に簡単です。 クラス内にクラスを記述するだけです。 クラスとは異なり、内部クラスはプライベートにすることができ、内部クラスをプライベートに宣言すると、クラス外部のオブジェクトからアクセスできなくなります。
以下は、内部クラスを作成してアクセスするプログラムです。 この例では、内部クラスをプライベートにし、メソッドを介してクラスにアクセスします。
例
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();
}
}ここで、 Outer_Demo は外部クラス、 Inner_Demo は内部クラス、* display_Inner（）は内部クラスをインスタンス化するメソッドであり、このメソッドは *main メソッドから呼び出されることがわかります。
上記のプログラムをコンパイルして実行すると、次の結果が得られます-
出力
This is an inner class.プライベートメンバーへのアクセス
前述のように、内部クラスはクラスのプライベートメンバーにアクセスするためにも使用されます。 クラスにアクセスするプライベートメンバーがいるとします。 内部クラスを記述し、内部クラス内のメソッド（* getValue（）*など）からプライベートメンバーを返し、最後に別のクラス（プライベートメンバーへのアクセス元）からgetValue（）メソッドを呼び出します内部クラス。
内部クラスをインスタンス化するには、最初に外部クラスをインスタンス化する必要があります。 その後、外部クラスのオブジェクトを使用して、内部クラスをインスタンス化する方法を次に示します。
Outer_Demo outer = new Outer_Demo();
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();次のプログラムは、内部クラスを使用してクラスのプライベートメンバーにアクセスする方法を示しています。
例
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());
}
}上記のプログラムをコンパイルして実行すると、次の結果が得られます-
出力
This is the getnum method of the inner class: 175メソッドローカル内部クラス
Javaでは、メソッド内にクラスを記述できます。これはローカル型になります。 ローカル変数と同様に、内部クラスのスコープはメソッド内で制限されます。
メソッドローカルの内部クラスは、内部クラスが定義されているメソッド内でのみインスタンス化できます。 次のプログラムは、メソッドローカルの内部クラスの使用方法を示しています。
例
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();
}
}上記のプログラムをコンパイルして実行すると、次の結果が得られます-
出力
This is method inner class 23匿名の内部クラス
クラス名なしで宣言された内部クラスは、*匿名内部クラス*として知られています。 匿名の内部クラスの場合、それらを同時に宣言およびインスタンス化します。 通常、クラスまたはインターフェイスのメソッドをオーバーライドする必要がある場合は常に使用されます。 匿名の内部クラスの構文は次のとおりです-
構文
AnonymousInner an_inner = new AnonymousInner() {
public void my_method() {
........
........
}
};次のプログラムは、匿名の内部クラスを使用してクラスのメソッドをオーバーライドする方法を示しています。
例
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();
}
}上記のプログラムをコンパイルして実行すると、次の結果が得られます-
出力
This is an example of anonymous inner class同様に、匿名内部クラスを使用して、具象クラスのメソッドとインターフェイスをオーバーライドできます。
引数としての匿名内部クラス
一般に、メソッドがインターフェイスのオブジェクト、抽象クラス、または具象クラスを受け入れる場合、インターフェイスを実装し、抽象クラスを拡張し、オブジェクトをメソッドに渡すことができます。 クラスである場合、メソッドに直接渡すことができます。
ただし、3つの場合すべてで、匿名の内部クラスをメソッドに渡すことができます。 ここにメソッドの引数として匿名の内部クラスを渡す構文があります-
obj.my_Method(new My_Class() {
public void Do() {
.....
.....
}
});次のプログラムは、メソッド引数として匿名内部クラスを渡す方法を示しています。
例
//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";
}
});
}
}上記のプログラムをコンパイルして実行すると、次の結果が得られます-
出力
Hello, This is an example of anonymous inner class as an argument静的ネストクラス
静的内部クラスは、外部クラスの静的メンバーであるネストされたクラスです。 他の静的メンバーを使用して、外部クラスをインスタンス化せずにアクセスできます。 静的メンバーのように、静的にネストされたクラスは、外部クラスのインスタンス変数とメソッドにアクセスできません。 静的なネストされたクラスの構文は次のとおりです-
構文
class MyOuter {
static class Nested_Demo {
}
}静的なネストされたクラスのインスタンス化は、内部クラスのインスタンス化とは少し異なります。 次のプログラムは、静的なネストされたクラスの使用方法を示しています。
例
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();
}
}上記のプログラムをコンパイルして実行すると、次の結果が得られます-
出力
This is my nested classJava-継承
継承は、あるクラスが別のクラスのプロパティ（メソッドとフィールド）を取得するプロセスとして定義できます。 継承を使用すると、情報は階層的な順序で管理可能になります。
他のプロパティを継承するクラスはサブクラス（派生クラス、子クラス）と呼ばれ、プロパティが継承されるクラスはスーパークラス（ベースクラス、親クラス）と呼ばれます。
キーワードを拡張
*extends* は、クラスのプロパティを継承するために使用されるキーワードです。 extendsキーワードの構文は次のとおりです。構文
class Super {
.....
.....
}
class Sub extends Super {
.....
.....
}サンプルコード
以下は、Javaの継承を示す例です。 この例では、CalculationとMy_Calculationという2つのクラスを観察できます。
extendsキーワードを使用して、My_Calculationは、Calculationクラスのメソッドadd（）およびSubtraction（）を継承します。
次のプログラムをコピーして、My_Calculation.javaという名前のファイルに貼り付けます
- 例 *
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);
}
}以下に示すように、上記のコードをコンパイルして実行します。
javac My_Calculation.java
java My_Calculationプログラムを実行した後、それは次の結果を生成します-
出力
The sum of the given numbers:30
The difference between the given numbers:10
The product of the given numbers:200指定されたプログラムでは、 My_Calculation クラスのオブジェクトが作成されると、スーパークラスのコンテンツのコピーがその中に作成されます。 そのため、サブクラスのオブジェクトを使用して、スーパークラスのメンバーにアクセスできます。
スーパークラス参照変数はサブクラスオブジェクトを保持できますが、その変数を使用するとスーパークラスのメンバーのみにアクセスできるため、両方のクラスのメンバーにアクセスするには、常にサブクラスへの参照変数を作成することをお勧めします。
上記のプログラムを検討する場合、以下に示すようにクラスをインスタンス化できます。 ただし、スーパークラス参照変数（この場合は cal ）を使用すると、サブクラスMy_Calculationに属するメソッド* multiplication（）*を呼び出すことはできません。
Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);注-サブクラスは、スーパークラスからすべてのメンバー（フィールド、メソッド、ネストされたクラス）を継承します。 コンストラクタはメンバではないので、それらはサブクラスによって継承されませんが、スーパークラスのコンストラクタはサブクラスから呼び出すことができます。
スーパーキーワード
*super* キーワードは *this* キーワードに似ています。 以下は、superキーワードが使用されるシナリオです。- 同じ名前を持つ場合、サブクラスのメンバーからスーパークラスのメンバーを区別するために使用されます。
- サブクラスからスーパークラスコンストラクターを呼び出すために使用されます。
メンバーの差別化
クラスが別のクラスのプロパティを継承している場合。 また、スーパークラスのメンバーの名前がサブクラスと同じ場合、これらの変数を区別するために、以下に示すようにスーパーキーワードを使用します。
super.variable
super.method();サンプルコード
このセクションでは、 super キーワードの使用法を示すプログラムを提供します。
指定されたプログラムには、_Sub_class_と_Super_class_という2つのクラスがあり、両方とも異なる実装のdisplay（）という名前のメソッドと、異なる値のnumという変数を持っています。 両方のクラスのdisplay（）メソッドを呼び出し、両方のクラスの変数numの値を出力しています。 ここで、スーパークラスのメンバーとサブクラスを区別するためにスーパーキーワードを使用したことがわかります。
Sub_class.javaという名前のファイルにプログラムをコピーして貼り付けます。
例
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プログラムを実行すると、次の結果が得られます-
出力
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キーワードを使用して、スーパークラスのパラメーター化されたコンストラクターを呼び出す方法を示しています。 このプログラムにはスーパークラスとサブクラスが含まれ、スーパークラスには整数値を受け入れるパラメーター化されたコンストラクターが含まれ、スーパーキーワードを使用してスーパークラスのパラメーター化されたコンストラクターを呼び出しました。
Subclass.javaという名前のファイルに次のプログラムをコピーして貼り付けます
例
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プログラムを実行すると、次の結果が得られます-
- 出力 *
The value of the variable named age in super class is: 24IS-A関係
IS-Aは、このオブジェクトの種類の1つです。* extends *キーワードを使用して継承を実現する方法を見てみましょう。
public class Animal {
}
public class Mammal extends Animal {
}
public class Reptile extends Animal {
}
public class Dog extends Mammal {
}さて、上記の例に基づいて、オブジェクト指向の用語では、次のとおりです-
- 動物は哺乳類クラスのスーパークラスです。
- 動物は爬虫類クラスのスーパークラスです。
- 哺乳類と爬虫類は動物クラスのサブクラスです。
- 犬は、哺乳類と動物の両方のクラスのサブクラスです。
今、IS-A関係を考慮する場合、次のように言えます-
- 哺乳類IS-A動物
- 爬虫類IS-A動物
- 犬IS-A哺乳類
- したがって：犬IS-A動物も
extendsキーワードを使用すると、サブクラスは、スーパークラスのプライベートプロパティを除く、スーパークラスのすべてのプロパティを継承できます。
インスタンス演算子を使用することで、哺乳類が実際に動物であることを保証できます。
例
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);
}
}これは、次の結果を生成します-
出力
true
true
true*extends* キーワードについて十分に理解しているため、IS-A関係を取得するために *implements* キーワードがどのように使用されるかを見てみましょう。一般に、 implements キーワードはクラスで使用され、インターフェイスのプロパティを継承します。 インターフェイスをクラスで拡張することはできません。
例
public interface Animal {
}
public class Mammal implements Animal {
}
public class Dog extends Mammal {
}instanceofキーワード
*instanceof* 演算子を使用して、哺乳類が実際に動物であり、犬が実際に動物であるかどうかを確認します。例
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);
}
}これは、次の結果を生成します-
出力
true
true
trueHAS-A関係
これらの関係は、主に使用法に基づいています。 これは、特定のクラスが HAS-A 特定のものであるかどうかを判別します。 この関係は、コードの重複とバグの削減に役立ちます。
例を見てみましょう-
例
public class Vehicle{}
public class Speed{}
public class Van extends Vehicle {
private Speed sp;
}これは、クラスVan HAS-A Speedを示しています。 Speedに個別のクラスを用意することで、speedに属するコード全体をVanクラスに入れる必要がなくなり、複数のアプリケーションでSpeedクラスを再利用できるようになります。
オブジェクト指向機能では、ユーザーはどのオブジェクトが実際の作業を行っているかを気にする必要はありません。 これを実現するために、Vanクラスは実装の詳細をVanクラスのユーザーから隠します。 したがって、基本的にユーザーはVanクラスに特定のアクションを実行するように要求し、Vanクラスは自分で作業を実行するか、別のクラスにアクションを実行するように要求します。
継承の種類
以下に示すように、継承にはさまざまなタイプがあります。
覚えておくべき非常に重要な事実は、Javaは多重継承をサポートしていないということです。 これは、クラスが複数のクラスを拡張できないことを意味します。 したがって、以下は違法です-
例
public class extends Animal, Mammal{}ただし、クラスは1つまたは複数のインターフェイスを実装できます。これにより、Javaは多重継承の不可能性を取り除くことができました。
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上記の例では、 b はAnimalのタイプですが、Dogクラスのmoveメソッドを実行していることがわかります。 その理由は次のとおりです。コンパイル時に、参照型に対してチェックが行われます。 ただし、ランタイムでは、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 errorbの参照型Animalにはbarkという名前のメソッドがないため、このプログラムはコンパイル時エラーをスローします。
メソッドのオーバーライドのルール
- 引数リストは、オーバーライドされたメソッドのリストとまったく同じでなければなりません。
- 戻り値の型は、スーパークラスの元のオーバーライドされたメソッドで宣言された戻り値の型と同じか、サブタイプでなければなりません。
- アクセスレベルは、オーバーライドされたメソッドのアクセスレベルよりも制限することはできません。 たとえば、スーパークラスメソッドがパブリックとして宣言されている場合、サブクラスのオーバーライドメソッドはプライベートまたは保護されません。
- インスタンスメソッドは、サブクラスによって継承される場合にのみオーバーライドできます。
- finalとして宣言されたメソッドはオーバーライドできません。
- staticと宣言されたメソッドはオーバーライドできませんが、再宣言できます。
- メソッドを継承できない場合は、オーバーライドできません。
- インスタンスのスーパークラスと同じパッケージ内のサブクラスは、privateまたはfinalとして宣言されていないスーパークラスメソッドをオーバーライドできます。
- 別のパッケージのサブクラスは、publicまたはprotectedとして宣言された非最終メソッドのみをオーバーライドできます。
- オーバーライドされたメソッドは、オーバーライドされたメソッドが例外をスローするかどうかに関係なく、チェック解除例外をスローできます。 ただし、オーバーライドするメソッドは、オーバーライドされたメソッドによって宣言されたものよりも新しい、または広範なチェック済み例外をスローしないでください。 オーバーライドするメソッドは、オーバーライドするメソッドよりも狭い、または少ない例外をスローできます。
- コンストラクターはオーバーライドできません。
superキーワードの使用
オーバーライドされたメソッドのスーパークラスバージョンを呼び出す場合、 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 runJava-ポリモーフィズム
多態性は、オブジェクトがさまざまな形をとる能力です。 OOPでの多態性の最も一般的な用途は、親クラスの参照を使用して子クラスのオブジェクトを参照するときに発生します。
複数のIS-Aテストに合格できるJavaオブジェクトは、ポリモーフィックと見なされます。 Javaでは、すべてのJavaオブジェクトはポリモーフィックです。これは、すべてのオブジェクトが独自の型およびクラスObjectのIS-Aテストに合格するためです。
オブジェクトにアクセスする唯一の方法は参照変数を使用することであることを知っておくことが重要です。 参照変数のタイプは1つのみです。 一度宣言すると、参照変数の型は変更できません。
参照変数は、最終宣言されていない限り、他のオブジェクトに再割り当てできます。 参照変数のタイプによって、オブジェクトで呼び出すことができるメソッドが決まります。
参照変数は、宣言された型のオブジェクトまたは宣言された型のサブタイプを参照できます。 参照変数は、クラス型またはインターフェイス型として宣言できます。
例
例を見てみましょう。
public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}これで、Deerクラスは複数の継承を持つため、ポリモーフィックであると見なされます。 上記の例には以下が当てはまります-
- 鹿は動物です
- 鹿はベジタリアンです
- 鹿IS-A鹿
- 鹿IS-Aオブジェクト
参照変数ファクトを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オブジェクトをインスタンス化します。 1つは給与参照 s を使用し、もう1つは従業員参照 e を使用します。
_s.mailCheck（）_を呼び出している間、コンパイラはコンパイル時にSalaryクラスのmailCheck（）を参照し、JVMは実行時にSalaryクラスのmailCheck（）を呼び出します。
*e* はEmployee参照であるため、 *e* のmailCheck（）はまったく異なります。 コンパイラが_e.mailCheck（）_を検出すると、コンパイラはEmployeeクラスでmailCheck（）メソッドを検出します。ここで、コンパイル時に、コンパイラーはEmployeeでmailCheck（）を使用してこのステートメントを検証しました。 ただし、実行時に、JVMはSalaryクラスのmailCheck（）を呼び出します。
この動作は仮想メソッド呼び出しと呼ばれ、これらのメソッドは仮想メソッドと呼ばれます。 上書きされたメソッドは、コンパイル時にソースコードで使用された参照のデータ型に関係なく、実行時に呼び出されます。
Java-抽象化
辞書によると、 abstraction は、イベントではなくアイデアを扱う品質です。 たとえば、電子メールの場合、電子メールを送信するとすぐに起こることなどの複雑な詳細を考慮すると、電子メールサーバーが使用するプロトコルはユーザーから隠されます。 したがって、電子メールを送信するには、コンテンツを入力し、受信者のアドレスを記載して、[送信]をクリックするだけです。
同様に、オブジェクト指向プログラミングでは、抽象化は実装の詳細をユーザーから隠すプロセスであり、機能のみがユーザーに提供されます。 言い換えると、ユーザーは、オブジェクトの動作方法ではなく、オブジェクトの動作に関する情報を取得します。
Javaでは、抽象クラスとインターフェイスを使用して抽象化が実現されます。
抽象クラス
宣言に abstract キーワードを含むクラスは、抽象クラスと呼ばれます。
- 抽象クラスには、abstractメソッド、つまり本体のないメソッドが含まれる場合と含まれない場合があります（public void get（）;
- ただし、クラスに少なくとも1つの抽象メソッドがある場合、そのクラスは抽象として宣言する必要があります。
- クラスが抽象として宣言されている場合、インスタンス化することはできません。
- 抽象クラスを使用するには、別のクラスから継承し、その中の抽象メソッドに実装を提供する必要があります。
- 抽象クラスを継承する場合は、その中のすべての抽象メソッドに実装を提供する必要があります。
例
このセクションでは、抽象クラスの例を示します。 抽象クラスを作成するには、クラス宣言で、classキーワードの前に abstract キーワードを使用するだけです。
/*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つのコンストラクターがあります。
今、あなたは次の方法で従業員クラスをインスタンス化しようとすることができます-
/*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抽象クラスの継承
私たちは、次の方法で具体的なクラスのように従業員クラスのプロパティを継承することができます-
例
/*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つの結果が生じます-
- それを含むクラスは抽象として宣言する必要があります。
- 現在のクラスを継承するクラスは、抽象メソッドをオーバーライドするか、自身を抽象として宣言する必要があります。
注-最終的に、子孫クラスは抽象メソッドを実装する必要があります。そうしないと、インスタンス化できない抽象クラスの階層ができてしまいます。
給与クラスが従業員クラスを継承し、次に示すように* 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
}Java-カプセル化
- カプセル化*は、4つの基本的なOOP概念の1つです。 他の3つは、継承、ポリモーフィズム、および抽象化です。
Javaでのカプセル化は、データ（変数）とデータに作用するコード（メソッド）を1つのユニットとしてラップするメカニズムです。 カプセル化では、クラスの変数は他のクラスから隠され、現在のクラスのメソッドを介してのみアクセスできます。 したがって、「データ隠蔽」とも呼ばれます。
Javaでカプセル化を達成するには-
- クラスの変数をプライベートとして宣言します。
- 変数値を変更および表示するためのパブリックセッターおよびゲッターメソッドを提供します。
例
以下は、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の参照型です。 クラスに似ています。 これは抽象メソッドの集まりです。 クラスはインタフェースを実装し、それによってインタフェースの抽象メソッドを継承します。
抽象メソッドに加えて、インタフェースには定数、デフォルトメソッド、静的メソッド、およびネストされた型も含まれる場合があります。 メソッド本体は、デフォルトメソッドと静的メソッドに対してのみ存在します。
インターフェイスの記述は、クラスの記述に似ています。 ただし、クラスはオブジェクトの属性と動作を記述します。 また、インターフェイスには、クラスが実装する動作が含まれます。
インターフェイスを実装するクラスが抽象クラスでない限り、インターフェイスのすべてのメソッドをクラスで定義する必要があります。
インターフェイスは、次の点でクラスに似ています-
- インターフェイスには、任意の数のメソッドを含めることができます。
- インターフェースは、拡張子が .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つの基本的な設計目的があります-
共通の親を作成します-Java APIの他の多数のインターフェースによって拡張されるEventListenerインターフェースと同様に、タグ付けインターフェースを使用して、インターフェースのグループ間で共通の親を作成できます。 たとえば、インターフェイスがEventListenerを拡張すると、JVMはこの特定のインターフェイスがイベント委任シナリオで使用されることを認識します。
データ型をクラスに追加します-この状況は、タギングという用語の由来です。 タグ付けインターフェースを実装するクラスは、メソッドを定義する必要はありませんが（インターフェースには何もないため）、クラスはポリモーフィズムによってインターフェース型になります。
Java-パッケージ
パッケージは、名前の競合を防ぎ、アクセスを制御し、クラス、インターフェイス、列挙、および注釈の検索/検索と使用を容易にするために、Javaで使用されます。
*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();
}さて、同じパッケージ_animals_に上記のインターフェースを実装しましょう-
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という名前のクラスが給与パッケージに追加されます。 ボスは、次のボスクラスで示すように、給与のプレフィックスを使用せずにEmployeeクラスを参照できます。
package payroll;
public class Boss {
public void payEmployee(Employee e) {
e.mailCheck();
}
}従業員クラスが給与パッケージにない場合はどうなりますか？ Bossクラスは、異なるパッケージ内のクラスを参照するために、次のいずれかの手法を使用する必要があります。
- クラスの完全修飾名を使用できます。 たとえば-
payroll.Employee- importキーワードとワイルドカード（*）を使用して、パッケージをインポートできます。 たとえば-
import payroll.*;- importキーワードを使用して、クラス自体をインポートできます。 たとえば-
import payroll.Employee;注-クラスファイルには、インポートステートメントをいくつでも含めることができます。 インポートステートメントは、パッケージステートメントの後、クラス宣言の前に表示する必要があります。
パッケージのディレクトリ構造
クラスがパッケージに配置されている場合、2つの主要な結果が発生します-
- 前のセクションで説明したように、パッケージの名前はクラスの名前の一部になります。
- パッケージの名前は、対応するバイトコードが存在するディレクトリ構造と一致する必要があります。
Javaでファイルを管理する簡単な方法を次に示します-
クラス、インターフェイス、列挙、または注釈タイプのソースコードを、名前がタイプの単純名で拡張子が .java のテキストファイルに入れます。
たとえば-
//File Name : Car.java
package vehicle;
public class Car {
//Class implementation.
}今、クラスが属するパッケージの名前を反映した名前を持つディレクトリにソースファイルを置きます-
....\vehicle\Car.java今、修飾クラス名とパス名は次のようになります-
- クラス名→vehicle.Car
- パス名→vehicle \ Car.java（Windows）
一般に、企業はパッケージ名に逆インターネットドメイン名を使用します。
例-会社のインターネットドメイン名はapple.comであり、すべてのパッケージ名はcom.appleで始まります。 パッケージ名の各コンポーネントは、サブディレクトリに対応しています。
例-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（ボーンシェル）で次のコマンドを使用します-
- Windowsの場合：C：\> CLASSPATHを設定します
- UNIXの場合→％echo $ CLASSPATH
CLASSPATH変数の現在の内容を削除するには、次を使用します-
- Windows→C：\> CLASSPATH =を設定します
- UNIXの場合→％unset CLASSPATH; CLASSPATHをエクスポート
CLASSPATH変数を設定するには-
- Windowsの場合→CLASSPATH = C：\ users \ jack \ java \ classesに設定します
- UNIXの場合→％CLASSPATH =/home/jack/java/classes; CLASSPATHをエクスポート
Java-データ構造
Javaユーティリティパッケージによって提供されるデータ構造は非常に強力で、さまざまな機能を実行します。 これらのデータ構造は、次のインターフェイスとクラスで構成されています-
- 列挙
- BitSet
- ベクター
- スタック
- 辞書
- ハッシュ表
- プロパティ
これらのクラスはすべてレガシーになり、Java-2はCollections Frameworkと呼ばれる新しいフレームワークを導入しました。これについては次の章で説明します。 −
列挙
Enumerationインターフェイス自体はデータ構造ではありませんが、他のデータ構造のコンテキスト内では非常に重要です。 Enumerationインターフェイスは、データ構造から連続した要素を取得する手段を定義します。
たとえば、Enumerationは、複数の要素を含むデータ構造内の次の要素を取得するために使用されるnextElementというメソッドを定義します。
このインターフェースの詳細については、リンク：/java/java_enumeration_interface [The Enumeration]を確認してください。
BitSet
BitSetクラスは、個別に設定およびクリアできるビットまたはフラグのグループを実装します。
このクラスは、一連のブール値に対応する必要がある場合に非常に役立ちます。各値にビットを割り当て、必要に応じて設定またはクリアするだけです。
このクラスの詳細については、リンク：/java/java_bitset_class [The BitSet]を確認してください。
ベクトル
Vectorクラスは、新しい要素に対応するために必要に応じて拡張できることを除いて、従来のJava配列に似ています。
配列と同様に、Vectorオブジェクトの要素には、ベクターへのインデックスを介してアクセスできます。
Vectorクラスを使用する利点は、作成時に特定のサイズに設定することを心配する必要がないことです。必要に応じて自動的に縮小および拡大します。
このクラスの詳細については、リンク：/java/java_vector_class [The Vector]を確認してください。
スタック
Stackクラスは、要素の先入れ先出し（LIFO）スタックを実装します。
スタックは、文字通りオブジェクトの垂直スタックと考えることができます。新しい要素を追加すると、他の要素の上に積み重ねられます。
スタックから要素を引き出すと、要素は一番上から外れます。 つまり、スタックに追加した最後の要素が、最初に戻ってくる要素です。
このクラスの詳細については、リンク：/java/java_stack_class [The Stack]を確認してください。
辞書
Dictionaryクラスは、キーを値にマッピングするためのデータ構造を定義する抽象クラスです。
これは、整数インデックスではなく特定のキーを介してデータにアクセスできるようにする場合に役立ちます。
Dictionaryクラスは抽象的であるため、特定の実装ではなく、キーマップデータ構造のフレームワークのみを提供します。
このクラスの詳細については、リンク：/java/java_dictionary_class [The Dictionary]を確認してください。
ハッシュテーブル
Hashtableクラスは、ユーザー定義のキー構造に基づいてデータを整理する手段を提供します。
たとえば、アドレス一覧のハッシュテーブルでは、人の名前ではなく郵便番号などのキーに基づいてデータを保存および並べ替えることができます。
ハッシュテーブルに関するキーの特定の意味は、ハッシュテーブルとそれに含まれるデータの使用法に完全に依存します。
このクラスの詳細については、リンク：/java/java_hashtable_class [The Hashtable]を確認してください。
プロパティ
プロパティはHashtableのサブクラスです。 キーが文字列で、値も文字列である値のリストを維持するために使用されます。
Propertiesクラスは、他の多くのJavaクラスで使用されます。 たとえば、環境値を取得するときにSystem.getProperties（）によって返されるオブジェクトのタイプです。
このクラスの詳細については、リンク：/java/java_properties_class [The Properties]を確認してください。
Java-コレクションフレームワーク
Java 2より前は、Javaは* Dictionary、Vector、Stack、、 *Properties などのアドホッククラスを提供して、オブジェクトのグループを格納および操作していました。 これらのクラスは非常に便利でしたが、中心的な統一テーマがありませんでした。 したがって、ベクターの使用方法は、プロパティの使用方法とは異なります。
コレクションフレームワークは、次のようないくつかの目標を満たすように設計されました-
- フレームワークは高性能でなければなりませんでした。 基本コレクション（動的配列、リンクリスト、ツリー、およびハッシュテーブル）の実装は、非常に効率的でした。
- フレームワークでは、さまざまなタイプのコレクションが同様の方法で、高度な相互運用性で動作できるようにする必要がありました。
- フレームワークは、コレクションを簡単に拡張および/または適合させる必要がありました。
このために、コレクションフレームワーク全体が一連の標準インターフェイスを中心に設計されています。 これらのインターフェイスの* LinkedList、HashSet、および *TreeSet などのいくつかの標準実装が提供され、そのまま使用することも、独自のコレクションを選択することもできます。
コレクションフレームワークは、コレクションを表現および操作するための統一されたアーキテクチャです。 すべてのコレクションフレームワークには以下が含まれます-
- インターフェイス-これらは、コレクションを表す抽象データ型です。 インターフェイスを使用すると、コレクションの表現の詳細に関係なくコレクションを操作できます。 オブジェクト指向言語では、インターフェイスは一般に階層を形成します。
- 実装、つまりクラス-これらはコレクションインターフェイスの具体的な実装です。 本質的に、それらは再利用可能なデータ構造です。
- アルゴリズム-これらは、コレクションインターフェイスを実装するオブジェクトに対して、検索や並べ替えなどの便利な計算を実行するメソッドです。 アルゴリズムはポリモーフィックであると言われています。つまり、適切なコレクションインターフェイスのさまざまな実装で同じメソッドを使用できます。
コレクションに加えて、フレームワークはいくつかのマップインターフェイスとクラスを定義します。 マップはキー/値のペアを保存します。 マップは用語の適切な使用では「コレクション」ではありませんが、コレクションと完全に統合されています。
コレクションインターフェイス
コレクションフレームワークは、いくつかのインターフェイスを定義します。 このセクションでは、各インターフェイスの概要を説明します-
| Sr.No. | Interface & Description |
|---|---|
| 1 |
これにより、オブジェクトのグループを操作できます。コレクション階層の最上部にあります。 |
| 2 |
これは Collection を拡張し、Listのインスタンスは要素の順序付けられたコレクションを格納します。 |
| 3 |
これは、コレクションを拡張して、一意の要素を含む必要があるセットを処理します。 |
| 4 |
これは、ソートされたセットを処理するためにSetを拡張します。 |
| 5 |
これにより、一意のキーが値にマップされます。 |
| 6 |
これは、マップ内の要素（キー/値のペア）を記述します。 これは、Mapの内部クラスです。 |
| 7 |
これにより、キーが昇順で維持されるようにMapが拡張されます。 |
| 8 |
これは、オブジェクトのコレクション内の要素を列挙（一度に1つずつ取得）できるメソッドを定義するレガシーインターフェイスです。 このレガシーインターフェイスはIteratorに取って代わられました。 |
コレクションクラス
Javaは、Collectionインターフェイスを実装する標準コレクションクラスのセットを提供します。 一部のクラスはそのまま使用できる完全な実装を提供し、他のクラスは抽象クラスであり、具体的なコレクションを作成するための開始点として使用される骨格実装を提供します。
標準コレクションクラスは、次の表にまとめられています-
| Sr.No. | Class & Description |
|---|---|
| 1 |
AbstractCollection Collectionインターフェイスのほとんどを実装します。 |
| 2 |
AbstractList AbstractCollectionを拡張し、Listインターフェイスのほとんどを実装します。 |
| 3 |
AbstractSequentialList 要素のランダムアクセスではなく順次アクセスを使用するコレクションで使用するために、AbstractListを拡張します。 |
| 4 |
AbstractSequentialListを拡張することにより、リンクリストを実装します。 |
| 5 |
AbstractListを拡張することにより、動的配列を実装します。 |
| 6 |
AbstractSet AbstractCollectionを拡張し、ほとんどのSetインターフェイスを実装します。 |
| 7 |
ハッシュテーブルで使用するためにAbstractSetを拡張します。 |
| 8 |
HashSetを拡張して、挿入順序の反復を可能にします。 |
| 9 |
ツリーに保存されたセットを実装します。 AbstractSetを拡張します。 |
| 10 |
AbstractMap Mapインターフェイスのほとんどを実装します。 |
| 11 |
ハッシュテーブルを使用するようにAbstractMapを拡張します。 |
| 12 |
ツリーを使用するようにAbstractMapを拡張します。 |
| 13 |
AbstractMapを拡張して、弱いキーを持つハッシュテーブルを使用します。 |
| 14 |
HashMapを拡張して、挿入順序の反復を可能にします。 |
| 15 |
AbstractMapを拡張し、ドキュメントを比較するときに参照の等価性を使用します。 |
AbstractCollection、AbstractSet、AbstractList、AbstractSequentialList、および_AbstractMap_クラスは、コアコレクションインターフェイスのスケルトン実装を提供し、実装に必要な労力を最小限に抑えます。
java.utilによって定義された次のレガシークラスは、前の章で議論されています-
| Sr.No. | Class & Description |
|---|---|
| 1 |
これにより、動的配列が実装されます。 ArrayListに似ていますが、いくつかの違いがあります。 |
| 2 |
スタックは、標準の先入れ先出しスタックを実装するベクターのサブクラスです。 |
| 3 |
辞書は、キー/値ストレージリポジトリを表す抽象クラスであり、Mapのように動作します。 |
| 4 |
Hashtableは元のjava.utilの一部であり、Dictionaryの具体的な実装です。 |
| 5 |
プロパティはHashtableのサブクラスです。 キーが文字列で、値も文字列である値のリストを維持するために使用されます。 |
| 6 |
BitSetクラスは、ビット値を保持する特別なタイプの配列を作成します。 この配列は、必要に応じてサイズを増やすことができます。 |
収集アルゴリズム
コレクションフレームワークは、コレクションとマップに適用できるいくつかのアルゴリズムを定義します。 これらのアルゴリズムは、コレクションクラス内の静的メソッドとして定義されます。
いくつかのメソッドは、互換性のない型を比較しようとするときに発生する ClassCastException 、または変更不可能なコレクションを変更しようとするときに発生する UnsupportedOperationException をスローできます。
コレクションは、EMPTY_SET、EMPTY_LIST、およびEMPTY_MAPの3つの静的変数を定義します。 すべて不変です。
| Sr.No. | Algorithm & Description |
|---|---|
| 1 |
すべてのアルゴリズム実装のリストを次に示します。 |
イテレータの使用方法
多くの場合、コレクション内の要素を循環する必要があります。 たとえば、各要素を表示できます。
これを行う最も簡単な方法は、イテレータを使用することです。イテレータは、イテレータまたはListIteratorインタフェースのいずれかを実装するオブジェクトです。
イテレータを使用すると、コレクションを循環して、要素を取得または削除できます。 ListIteratorは、Iteratorを拡張して、リストの双方向の走査と要素の変更を可能にします。
| Sr.No. | Iterator Method & Description |
|---|---|
| 1 |
以下に、IteratorおよびListIteratorインターフェースによって提供される例を含むすべてのメソッドのリストを示します。 |
コンパレータの使用方法
TreeSetとTreeMapはどちらも、要素をソートされた順序で保存します。 ただし、_sorted order_の意味を正確に定義するのはコンパレータです。
このインターフェイスを使用すると、特定のコレクションをさまざまな方法で並べ替えることができます。 また、このインターフェイスを使用して、クラスのインスタンス（変更できないクラスも含む）を並べ替えることができます。
| Sr.No. | Iterator Method & Description |
|---|---|
| 1 |
以下は、Comparator Interfaceが提供するすべてのメソッドと例のリストです。 |
概要
Javaコレクションフレームワークを使用すると、プログラマは、あらかじめパッケージ化されたデータ構造と、それらを操作するアルゴリズムにアクセスできます。
コレクションは、他のオブジェクトへの参照を保持できるオブジェクトです。 コレクションインターフェイスは、各タイプのコレクションで実行できる操作を宣言します。
コレクションフレームワークのクラスとインターフェースは、パッケージjava.utilにあります。
Java-ジェネリック
整数配列、文字列配列、または順序付けをサポートする任意のタイプの配列内の要素を並べ替えることができる単一の並べ替えメソッドを作成できれば便利です。
Javaの Generic メソッドとジェネリッククラスを使用すると、プログラマは、単一のメソッド宣言、関連するメソッドのセット、または単一のクラス宣言、関連するタイプのセットをそれぞれ指定できます。
ジェネリックはまた、プログラマがコンパイル時に無効な型をキャッチできるコンパイル時の型安全性も提供します。
Javaジェネリックコンセプトを使用して、オブジェクトの配列を並べ替えるためのジェネリックメソッドを記述し、整数配列、ダブル配列、ストリング配列などでジェネリックメソッドを呼び出して、配列要素を並べ替えます。
ジェネリックメソッド
異なる型の引数で呼び出すことができる単一のジェネリックメソッド宣言を作成できます。 ジェネリックメソッドに渡される引数のタイプに基づいて、コンパイラは各メソッド呼び出しを適切に処理します。 以下は、ジェネリックメソッドを定義するルールです-
- すべてのジェネリックメソッド宣言には、メソッドの戻り型（次の例では<E>）の前に山括弧（<および>）で区切られた型パラメーターセクションがあります。
- 各型パラメーターセクションには、カンマで区切られた1つ以上の型パラメーターが含まれています。 型パラメーターとも呼ばれる型変数は、一般的な型名を指定する識別子です。
- 型パラメーターを使用して戻り型を宣言し、ジェネリックメソッドに渡される引数の型のプレースホルダーとして機能することができます。これは実際の型引数として知られています。
- ジェネリックメソッドの本体は、他のメソッドの本体と同様に宣言されます。 型パラメーターは参照型のみを表すことができ、プリミティブ型（int、double、charなど）は表すことができないことに注意してください。
例
次の例は、単一のGenericメソッドを使用して異なるタイプの配列を印刷する方法を示しています-
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有界型パラメータ
型パラメータに渡すことができる型の種類を制限したい場合があるかもしれません。 たとえば、数値を操作するメソッドは、Numberまたはそのサブクラスのインスタンスのみを受け入れたい場合があります。 これが境界型パラメータの目的です。
制限された型パラメーターを宣言するには、型パラメーターの名前をリストし、その後にextendsキーワードとその上限をリストします。
例
次の例は、extends（クラスなど）または「implements」（インターフェイスなど）を意味する一般的な意味でのextendの使用方法を示しています。 この例は、3つのComparableオブジェクトのうち最大のものを返す汎用メソッドです-
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 WorldJava-シリアル化
Javaには、オブジェクトのデータと、オブジェクトの型とオブジェクトに格納されているデータの型に関する情報を含むバイトシーケンスとしてオブジェクトを表すことができるオブジェクトシリアル化と呼ばれるメカニズムがあります。
シリアル化されたオブジェクトは、ファイルに書き込まれた後、ファイルから読み取られて逆シリアル化されます。つまり、オブジェクトとそのデータを表す型情報とバイトを使用して、オブジェクトをメモリに再作成できます。
最も印象的なのは、プロセス全体がJVMに依存しないことです。つまり、オブジェクトを1つのプラットフォームでシリアル化し、完全に異なるプラットフォームで逆シリアル化できます。
クラス ObjectInputStream および ObjectOutputStream は、オブジェクトをシリアライズおよびデシリアライズするためのメソッドを含む高レベルのストリームです。
ObjectOutputStreamクラスには、さまざまなデータ型を書き込むための多くの書き込みメソッドが含まれていますが、特に1つのメソッドが際立っています-
public final void writeObject(Object x) throws IOException上記のメソッドはオブジェクトをシリアル化し、出力ストリームに送信します。 同様に、ObjectInputStreamクラスには、オブジェクトをデシリアライズするための次のメソッドが含まれています-
public final Object readObject() throws IOException, ClassNotFoundExceptionこのメソッドは、ストリームから次のオブジェクトを取得し、逆シリアル化します。 戻り値はオブジェクトなので、適切なデータ型にキャストする必要があります。
Javaでシリアル化がどのように機能するかを示すために、本書の早い段階で説明したEmployeeクラスを使用します。 Serializableインターフェイスを実装する次のEmployeeクラスがあるとします-
例
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標準クラスがシリアル化可能かどうか知りたい場合は、クラスのドキュメントを確認してください。 テストは簡単です。クラスがjava.io.Serializableを実装している場合、それはシリアライズ可能です。そうでなければ、そうではありません。
オブジェクトのシリアル化
ObjectOutputStreamクラスは、オブジェクトのシリアル化に使用されます。 次のSerializeDemoプログラムは、Employeeオブジェクトをインスタンス化し、ファイルにシリアル化します。
プログラムの実行が完了すると、employee.serという名前のファイルが作成されます。 プログラムは出力を生成しませんが、コードを調べてプログラムが何をしているかを判断しようとします。
注-オブジェクトをファイルにシリアル化する場合、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は、オブジェクトの逆シリアル化中にクラスを見つけられない場合、ClassNotFoundExceptionをスローします。
- readObject（）の戻り値がEmployee参照にキャストされることに注意してください。
- SSNフィールドの値は、オブジェクトがシリアル化されたときは11122333でしたが、このフィールドは一時的なため、この値は出力ストリームに送信されませんでした。 デシリアライズされたEmployeeオブジェクトのSSNフィールドは0です。
Java-ネットワーキング
「ネットワークプログラミング」という用語は、複数のデバイス（コンピューター）で実行されるプログラムを作成することを指し、デバイスはすべてネットワークを使用して互いに接続されています。
J2SE APIのjava.netパッケージには、低レベルの通信の詳細を提供するクラスとインターフェースのコレクションが含まれており、問題の解決に焦点を当てたプログラムを作成できます。
java.netパッケージは、2つの一般的なネットワークプロトコルのサポートを提供します-
- TCP -TCPはTransmission Control Protocolの略で、2つのアプリケーション間の信頼できる通信を可能にします。 TCPは通常、TCP/IPと呼ばれるインターネットプロトコルで使用されます。
- UDP -UDPはUser Datagram Protocolの略で、アプリケーション間でデータのパケットを送信できるコネクションレスプロトコルです。
この章では、次の2つの主題について十分に理解します。
- ソケットプログラミング-これは、ネットワーキングで最も広く使用されている概念であり、非常に詳細に説明されています。
- URL Processing -これについては個別に説明します。 Java言語でのリンク：/java/java_url_processing [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つのコンストラクタがあります-
| Sr.No. | Method & Description |
|---|---|
| 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クラスの一般的なメソッドの一部です-
| Sr.No. | Method & Description |
|---|---|
| 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* クラスは、クライアントとサーバーの両方が互いに通信するために使用するソケットを表します。 クライアントはSocketオブジェクトをインスタンス化して取得しますが、サーバーはaccept（）メソッドの戻り値からSocketオブジェクトを取得します。Socketクラスには、クライアントがサーバーへの接続に使用する5つのコンストラクターがあります-
| Sr.No. | Method & Description |
|---|---|
| 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. このメソッドは、ホストがStringではなくInetAddressオブジェクトで示されることを除いて、前のコンストラクターと同じです。 |
| 5 |
public Socket() 接続されていないソケットを作成します。 connect（）メソッドを使用して、このソケットをサーバーに接続します。 |
Socketコンストラクターが戻ると、単にSocketオブジェクトをインスタンス化するのではなく、指定されたサーバーとポートへの接続を実際に試行します。
Socketクラスに関係するいくつかのメソッドをここにリストします。 クライアントとサーバーの両方にSocketオブジェクトがあるため、これらのメソッドはクライアントとサーバーの両方から呼び出すことができます。
| Sr.No. | Method & Description |
|---|---|
| 1 |
public void connect(SocketAddress host, int timeout) throws IOException このメソッドは、指定されたホストにソケットを接続します。 このメソッドは、引数なしのコンストラクタを使用してSocketをインスタンス化する場合にのみ必要です。 |
| 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）アドレスを表します。 以下は、ソケットプログラミングを行う際に必要となる便利なメソッドです。
| Sr.No. | Method & Description |
|---|---|
| 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プログラムは、コマンドライン引数で指定されたポート番号でクライアントをリッスンするためにソケットクラスを使用するサーバーアプリケーションの例です-
例
//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-メールの送信
Javaアプリケーションを使用して電子メールを送信するのは非常に簡単ですが、最初に JavaMail API と* Java Activation Framework（JAF）*をマシンにインストールする必要があります。
- Javaの標準Webサイトからhttps://java.sun.com/products/javamail/[JavaMail（Version 1.2）]の最新バージョンをダウンロードできます。
- 最新バージョンのhttps://java.sun.com/products/javabeans/glasgow/jafl[JAF（Version 1.1.1）]は、Javaの標準Webサイトからダウンロードできます。
これらのファイルをダウンロードして解凍すると、新しく作成された最上位ディレクトリに、両方のアプリケーションの多数のjarファイルがあります。 CLASSPATHに mail.jar および activation.jar ファイルを追加する必要があります。
簡単なメールを送信する
以下は、マシンから簡単な電子メールを送信する例です。 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
- アドレス-これは電子メール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は_マルチスレッドプログラミング言語_です。つまり、Javaを使用してマルチスレッドプログラムを開発できます。 マルチスレッドプログラムには、同時に実行できる2つ以上のパーツが含まれており、各パーツが同時に異なるタスクを処理して、コンピューターに複数のCPUがある場合に利用可能なリソースを特に最適に使用できます。
定義上、マルチタスクとは、複数のプロセスがCPUなどの共通の処理リソースを共有することです。 マルチスレッドは、マルチタスクの概念をアプリケーションに拡張し、単一のアプリケーション内の特定の操作を個々のスレッドに細分することができます。 各スレッドは並行して実行できます。 OSは、異なるアプリケーション間だけでなく、アプリケーション内の各スレッド間でも処理時間を分割します。
マルチスレッドを使用すると、同じプログラムで複数のアクティビティを同時に実行できるように記述できます。
スレッドのライフサイクル
スレッドは、ライフサイクルのさまざまな段階を経ます。 たとえば、スレッドが生成され、開始され、実行された後、終了します。 次の図は、スレッドの完全なライフサイクルを示しています。
ライフサイクルの段階は次のとおりです-
- New -新しいスレッドは、新しい状態でライフサイクルを開始します。 プログラムがスレッドを開始するまで、この状態のままです。 また、「生まれた糸」とも呼ばれます。
- 実行可能-新しく生成されたスレッドが開始された後、スレッドは実行可能になります。 この状態のスレッドは、タスクを実行していると見なされます。
- 待機-時々、スレッドは待機状態に移行しますが、スレッドは別のスレッドがタスクを実行するのを待機します。 別のスレッドが実行を継続するために待機中のスレッドに信号を送る場合にのみ、スレッドは実行可能状態に戻ります。
- Timed Waiting -実行可能なスレッドは、指定された時間間隔で時間指定された待機状態に入ることができます。 この状態のスレッドは、その時間間隔が経過するか、待機しているイベントが発生すると、実行可能な状態に戻ります。
- * Terminated（Dead）*-実行可能なスレッドは、タスクを完了するか、他の方法で終了すると、終了状態になります。
スレッドの優先度
すべてのJavaスレッドには、オペレーティングシステムがスレッドのスケジュール順序を決定するのに役立つ優先順位があります。
Javaスレッドの優先順位は、MIN_PRIORITY（定数1）からMAX_PRIORITY（定数10）の範囲です。 デフォルトでは、すべてのスレッドに優先順位NORM_PRIORITY（5の定数）が与えられます。
優先度の高いスレッドはプログラムにとってより重要であり、優先度の低いスレッドよりも前にプロセッサ時間を割り当てる必要があります。 ただし、スレッドの優先順位は、スレッドの実行順序を保証できず、プラットフォームに大きく依存します。
実行可能なインターフェイスを実装してスレッドを作成する
クラスがスレッドとして実行されることを意図している場合、 Runnable インターフェースを実装することでこれを実現できます。 あなたは3つの基本的な手順に従う必要があります-
ステップ1
最初のステップとして、 Runnable インターフェースによって提供されるrun（）メソッドを実装する必要があります。 このメソッドはスレッドのエントリポイントを提供し、このメソッド内に完全なビジネスロジックを配置します。 以下は、run（）メソッドの簡単な構文です-
public void run( )ステップ2
2番目のステップとして、次のコンストラクタを使用して*スレッド*オブジェクトをインスタンス化します-
Thread(Runnable threadObj, String threadName);ここで、_threadObj_は Runnable インターフェイスを実装するクラスのインスタンスであり、 threadName は新しいスレッドに付けられた名前です。
ステップ3
Threadオブジェクトが作成されたら、* 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番目の方法は、次の2つの簡単な手順を使用して Thread クラスを拡張する新しいクラスを作成することです。 このアプローチにより、Threadクラスの利用可能なメソッドを使用して作成された複数のスレッドをより柔軟に処理できます。
ステップ1
Threadクラスで利用可能な* run（）*メソッドをオーバーライドする必要があります。 このメソッドはスレッドのエントリポイントを提供し、このメソッド内に完全なビジネスロジックを配置します。 以下は、run（）メソッドの簡単な構文です-
public void run( )ステップ2
Threadオブジェクトが作成されたら、* 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クラスで使用できる重要なメソッドのリストです。
| Sr.No. | Method & Description |
|---|---|
| 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つを呼び出すと、現在実行中のスレッドで操作が実行されます。
| Sr.No. | Method & Description |
|---|---|
| 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クラスのこれらのメソッドの一部を示しています。 Runnable を実装するクラス DisplayMessage を検討します-
//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);
}
}
}以下は、スレッドクラスを拡張する別のクラスです-
//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でマルチスレッドプログラミングをしている間、次の概念が非常に便利である必要があります-
- リンク：/java/java_thread_synchronization [スレッド同期とは？]
- リンク：/java/java_thread_communication [スレッド間通信の処理]
- リンク：/java/java_thread_deadlock [スレッドデッドロックの処理]
- リンク：/java/java_thread_control [主なスレッド操作]
Java-アプレットの基本
- アプレット*は、Webブラウザで実行されるJavaプログラムです。 アプレットは、Java API全体を自由に使用できるため、完全に機能するJavaアプリケーションにすることができます。
アプレットとスタンドアロンJavaアプリケーションには、次のような重要な違いがいくつかあります-
- アプレットは、java.applet.Appletクラスを拡張するJavaクラスです。
- main（）メソッドはアプレットで呼び出されず、アプレットクラスはmain（）を定義しません。
- アプレットは、HTMLページに埋め込まれるように設計されています。
- ユーザーがアプレットを含むHTMLページを表示すると、アプレットのコードがユーザーのマシンにダウンロードされます。
- アプレットを表示するにはJVMが必要です。 JVMは、Webブラウザーのプラグインまたは別個のランタイム環境のいずれかです。
- ユーザーのマシン上のJVMは、アプレットクラスのインスタンスを作成し、アプレットの有効期間中にさまざまなメソッドを呼び出します。
- アプレットには、Webブラウザによって実施される厳格なセキュリティルールがあります。 アプレットのセキュリティは、サンドボックスセキュリティと呼ばれることが多く、アプレットを、従う必要のあるさまざまなルールを使用してサンドボックスで遊ぶ子供と比較します。
- アプレットに必要な他のクラスは、単一のJava Archive（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コンパイラは、アプレットクラスが参照するクラスAppletおよびGraphicsを認識しません。
アプレットクラス
すべてのアプレットは、_java.applet.Applet class_の拡張です。 ベースAppletクラスは、派生アプレットクラスがブラウザコンテキストから情報とサービスを取得するために呼び出すメソッドを提供します。
これらには、次のことを行うメソッドが含まれます-
- アプレットのパラメーターを取得する
- アプレットを含むHTMLファイルのネットワーク上の場所を取得します
- アプレットクラスディレクトリのネットワークの場所を取得する
- ブラウザーでステータスメッセージを印刷する
- 画像を取得する
- オーディオクリップを取得する
- オーディオクリップを再生する
- アプレットのサイズを変更する
さらに、アプレットクラスは、ビューアまたはブラウザがアプレットに関する情報を取得し、アプレットの実行を制御するインターフェイスを提供します。 視聴者は可能性があります-
- アプレットの作成者、バージョン、著作権に関する情報を要求する
- アプレットが認識するパラメーターの説明を要求する
- アプレットを初期化する
- アプレットを破壊する
- アプレットの実行を開始します
- アプレットの実行を停止する
Appletクラスは、これらの各メソッドのデフォルト実装を提供します。 これらの実装は、必要に応じてオーバーライドできます。
「Hello、World」アプレットはそのままです。 オーバーライドされる唯一のメソッドはpaintメソッドです。
アプレットの呼び出し
アプレットを呼び出すには、ディレクティブを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>注意-HTMLからのアプレットの呼び出しの詳細については、リンク：/html/html_applet_tag [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値にします。 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>注意-パラメータ名は大文字と小文字を区別しません。
アプレットへのアプリケーション変換
グラフィカルなJavaアプリケーション（つまり、AWTを使用し、Javaプログラムランチャーで起動できるアプリケーション）を、Webページに埋め込むことができるアプレットに簡単に変換できます。
以下は、アプリケーションをアプレットに変換するための特定の手順です。
- 適切なタグを使用してHTMLページを作成し、アプレットコードをロードします。
- JAppletクラスのサブクラスを提供します。 このクラスを公開します。 そうしないと、アプレットをロードできません。
- アプリケーションのメインメソッドを削除します。 アプリケーションのフレームウィンドウを構築しないでください。 アプリケーションがブラウザ内に表示されます。
- 初期化コードをフレームウィンドウコンストラクターからアプレットの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オブジェクトを取得するには、AppletクラスのgetAudioClip（）メソッドを呼び出す必要があります。 URLが実際のオーディオファイルに解決されるかどうかにかかわらず、getAudioClip（）メソッドはすぐに戻ります。 オーディオファイルは、オーディオクリップを再生しようとするまでダウンロードされません。
以下は、オーディオを再生するためのすべての手順を示す例です-
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-ドキュメントのコメント
Java言語は、3種類のコメントをサポートしています-
| Sr.No. | Comment & Description |
|---|---|
| 1 |
/*text/* コンパイラは、/*から */までのすべてを無視します。 |
| 2 |
//text コンパイラは//から行末までのすべてを無視します。 |
| 3 |
/ documentation/* これはドキュメンテーションコメントであり、一般的には* docコメント*と呼ばれます。 JDK javadoc ツールは、自動生成されたドキュメントを準備するときに_docコメント_を使用します。 |
この章では、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ツールは、次のタグを認識します-
| Tag | Description | Syntax |
|---|---|---|
| @author | Adds the author of a class. | @author name-text |
| \{@code} | Displays text in code font without interpreting the text as HTML markup or nested javadoc tags. | \{@code text} |
| \{@docRoot} | Represents the relative path to the generated document’s root directory from any generated page. | \{@docRoot} |
| @deprecated | Adds a comment indicating that this API should no longer be used. | @deprecated deprecatedtext |
| @exception | Adds a *Throws *subheading to the generated documentation, with the classname and description text. | @exception class-name description |
| \{@inheritDoc} | Inherits a comment from the* nearest* inheritable class or implementable interface. | Inherits a comment from the immediate surperclass. |
| \{@link} | Inserts an in-line link with the visible text label that points to the documentation for the specified package, class, or member name of a referenced class. | \{@link package.class#member label} |
| \{@linkplain} | Identical to \{@link}, except the link’s label is displayed in plain text than code font. | \{@linkplain package.class#member label} |
| @param | Adds a parameter with the specified parameter-name followed by the specified description to the "Parameters" section. | @param parameter-name description |
| @return | Adds a "Returns" section with the description text. | @return description |
| @see | Adds a "See Also" heading with a link or text entry that points to reference. | @see reference |
| @serial | Used in the doc comment for a default serializable field. | @serial field-description |
| include | exclude | @serialData |
| Documents the data written by the writeObject( ) or writeExternal( ) methods. | @serialData data-description | @serialField |
| Documents an ObjectStreamField component. | @serialField field-name field-type field-description | @since |
| Adds a "Since" heading with the specified since-text to the generated documentation. | @since release | @throws |
| The @throws and @exception tags are synonyms. | @throws class-name description | \{@value} |
| When \{@value} is used in the doc comment of a static field, it displays the value of that constant. | \{@value package.class#field} | @version |
例
次のプログラムでは、ドキュメントのコメントに使用できる重要なタグのいくつかを使用しています。 要件に基づいて他のタグを使用できます。
AddNumクラスに関するドキュメントは、HTMLファイルAddNumlで作成されますが、同時に、indexlという名前のマスターファイルも作成されます。
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/AddNuml...
AddNum.java:36: warning - @return tag cannot be used in method with void return type.
Generating/package-framel...
Generating/package-summaryl...
Generating/package-treel...
Generating/constant-valuesl...
Building index for all the packages and classes...
Generating/overview-treel...
Generating/index-alll...
Generating/deprecated-listl...
Building index for all classes...
Generating/allclasses-framel...
Generating/allclasses-noframel...
Generating/indexl...
Generating/help-docl...
1 warning
$ここで生成されたすべてのドキュメントをチェックできます-https://www.finddevguides.com/java/indexl[AddNum]。 JDK 1.7を使用している場合、javadocは素晴らしい stylesheet.css を生成しないため、https://docs.oracle.com/javase/7/docs/api/stylesheet.cssから標準スタイルシートをダウンロードして使用することをお勧めします。 Java-questions-answers
