プロジェクトが気に入ったらクリックしてください。あなたの貢献を心から歓迎します。
マルチスレッド化
コレクション
Java データベース接続 (JDBC)
Java プログラム
Java 文字列メソッド
ジャカルタ サーバー ページ (JSP)
サーブレット
Java の多肢選択問題
Java デザイン パターン
休止状態
Spring フレームワークの基本
導入
Java アーキテクチャ
Javaのデータ型
Javaメソッド
Java 関数型プログラミング
Java ラムダ式
Javaクラス
Java コンストラクター
Java配列
Java 文字列
Java リフレクション
Javaストリーム
Javaの正規表現
Java ファイルの処理
Javaの例外
Javaの継承
Java メソッドのオーバーライド
Javaポリモーフィズム
Javaの抽象化
Javaインターフェース
Java カプセル化
Java ジェネリックス
その他
デフォルトではインターフェースメソッド。
ラムダ式。
機能的なインターフェース。
メソッドとコンストラクターへの参照。
反復可能な注釈
データ型に関する注釈。
メソッドパラメータのリフレクション。
コレクションを操作するためのストリーム API。
配列の並列ソート。
日付と時刻を操作するための新しい API。
新しい JavaScript Nashorn エンジン ;
スレッドセーフな操作のためにいくつかの新しいクラスを追加しました。
Calendar
とLocale
用の新しい API を追加しました。
Unicode 6.2.0 のサポートを追加しました。
Base64 を操作するための標準クラスを追加しました。
符号なし算術のサポートが追加されました。
コンストラクターjava.lang.String(byte[], *)
とメソッドのパフォーマンスjava.lang.String.getBytes()
が改善されました。
新しい実装AccessController.doPrivileged
により、 * 他のアクセス レベルをすべてチェックすることなく、権限のサブセットを設定できるようになります。
パスワードベースのアルゴリズムはより堅牢になりました。
JSSE サーバーに SSL / TLS サーバー名表示 (NSI) のサポートが追加されました。
キーストア (KeyStore) の改善。
SHA-224 アルゴリズムを追加しました。
JDBC ブリッジ - ODBC を削除しました。
PermGen は削除され、クラスのメタデータを保存する方法が変更されます。
Java SE プラットフォーム用のプロファイルを作成する機能。これにはプラットフォーム全体ではなく、その一部が含まれます。
ツール
JavaScript Nashorn を使用するためのユーティリティjjs
追加しました。
コマンドjava
JavaFX アプリケーションを実行できます。
.class ファイルを分析するためのユーティリティjdeps
追加しました。
↥ トップに戻る
Nashorn は、Oracle が Java で開発した JavaScript エンジンです。 Java アプリケーションに JavaScript コードを埋め込む機能を提供するように設計されています。 Mozilla Foundation によってサポートされている Rhino と比較して、Nashorn はコードをコンパイルし、メモリ内で直接 Java 仮想マシンにバイトコードを転送するため、2 ~ 10 倍優れたパフォーマンスを提供します。 Nashorn は、JavaScript コードをコンパイルし、特別なローダーでロードされる Java クラスを生成できます。 JavaScript から Java コードを直接呼び出すこともできます。
↥ トップに戻る
jjs
- これは、JavaScript プログラムをコンソールで直接実行できるようにするコマンド ライン ユーティリティです。
↥ トップに戻る
Java では、コマンドライン環境 ( console ) でユーザーからの入力を読み取るための 3 つの異なる方法があります。
1. バッファー リーダー クラスの使用:
このメソッドは、BufferedReader でラップされた InputStreamReader で System.in (標準入力ストリーム) をラップすることによって使用され、コマンド ラインでユーザーからの入力を読み取ることができます。
/** * バッファード リーダー クラス */import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class Test { public static void main(String[] args) throws IOException { // Enter BufferReader を使用したデータ BufferedReader Reader = new BufferedReader(new InputStreamReader(System.in)); // readLine を使用してデータを読み取る String name = Reader.readLine(); // 読み取った行を印刷します System.out.println(name); } }
2. スキャナ クラスの使用:
Scanner クラスの主な目的は、正規表現を使用してプリミティブ型と文字列を解析することですが、コマンド ラインでユーザーからの入力を読み取るために使用することもできます。
/** * スキャナ クラス */import java.util.Scanner;class GetInputFromUser { public static void main(String args[]) { // ユーザーからの入力を取得するためにスキャナを使用する Scanner in = new Scanner(System.in); 文字列 s = in.nextLine(); System.out.println("文字列を入力しました " + s); int a = in.nextInt(); System.out.println("整数を入力しました " + a); float b = in.nextFloat(); System.out.println("float を入力しました " + b); } }
3. コンソール クラスの使用:
これは、コマンド ラインからユーザーの入力を読み取るための推奨される方法になりつつあります。さらに、ユーザーが入力した文字をエコーすることなく、パスワードのような入力を読み取るために使用できます。フォーマット文字列構文も使用できます ( System.out.printf() など)。
/** * Console Class */public class Sample { public static void main(String[] args) { // Console を使用してユーザーからデータを入力 String name = System.console().readLine(); System.out.println(名前); } }
↥ トップに戻る
javapコマンドは、クラス ファイル内に存在するフィールド、コンストラクター、およびメソッドに関する情報を表示します。 javap コマンド ( Java 逆アセンブラ とも呼ばれる) は、1 つ以上のクラス ファイルを逆アセンブルします。
/** * Java 逆アセンブラ */class Simple { public static void main(String args[]) { System.out.println("Hello World"); } }
cmd> javap Simple.class
出力
「.java」クラスからコンパイルされた Simple { 単純(); public static void main(java.lang.String[]); }
↥ トップに戻る
System.out::println
という式について説明してください。指定された式は、 println()
クラスSystem.out
の静的メソッドへの参照を渡すことを示しています。
↥ トップに戻る
ストリームは順次でも並列でも可能です。順次ストリームでの操作は 1 つのプロセッサ スレッドで実行され、並列ストリームでは複数のプロセッサ スレッドを使用して実行されます。並列ストリームは、静的ForkJoinPool.commonPool()
メソッドを通じて共有ストリームForkJoinPool
を使用します。この場合、環境がマルチコアでない場合、ストリームはシーケンシャルとして実行されます。実際、並列ストリームの使用は、ストリーム内のデータが部分に分割され、各部分が個別のプロセッサ コアで処理され、最終的にこれらの部分が接続され、最終的な操作が実行されるという事実に帰着します。彼ら。
また、 parallelStream()
インターフェイス メソッドを使用して、コレクションCollection
から並列ストリームを作成することもできます。
通常の順次ストリームを並列化するには、 parallel()
のStream
メソッドを呼び出す必要があります。 isParallel()
メソッドを使用すると、ストリームが並列かどうかを確認できます。
メソッドparallel()
およびsequential()
を使用すると、どの操作が並列可能で、どの操作が順次のみであるかを決定できます。任意のシーケンシャル ストリームからパラレル ストリームを作成することも、その逆も行うことができます。
コレクション 。ストリーム () .peek ( ... ) // 操作はシーケンシャルです 。平行 () .map ( ... ) // 操作は並行して実行できます。 。一連 () .reduce ( ... ) // 操作は再びシーケンシャルです
通常、要素はデータ ソースで定義されているのと同じ順序でストリームに転送されます。並列ストリームを操作する場合、システムは要素のシーケンスを保持します。例外は、要素をランダムな順序で出力できるforEach()
メソッドです。そして、順序を維持するには、 forEachOrdered()
メソッドを適用する必要があります。
並列ストリームのパフォーマンスに影響を与える可能性のある基準は次のとおりです。
データ サイズ - データが多くなるほど、最初にデータを分離してから結合することが難しくなります。
プロセッサコアの数。理論的には、コンピューターのコアが多いほど、プログラムの動作は速くなります。マシンにコアが 1 つある場合、並列スレッドを使用するのは意味がありません。
ストリームが扱うデータ構造が単純であればあるほど、より高速な操作が実行されます。たとえば、 ArrayList
からのデータは、このコレクションの構造が無関係なデータのシーケンスを想定しているため、使いやすくなっています。ただし、連続リストではすべての要素が前/次と接続されているため、型コレクションLinkedList
最良のオプションではありません。そして、そのようなデータは並列化することが困難です。
プリミティブ型を使用した操作は、クラス オブジェクトを使用した場合よりも高速になります。
すべての並列ストリームは 1 つのForkJoinPool
で動作するため、長時間の操作 (ネットワーク接続など) には並列ストリームを使用しないことを強くお勧めします。そのような長時間の操作では、使用可能なスレッドの不足により JVM 内のすべての並列ストリームが停止する可能性があります。プールなどで e.並列ストリームは、カウントがミリ秒単位になる短い操作にのみ使用する必要があり、カウントが秒や分単位になる場合には使用しないでください。
並列ストリームで順序を保存すると、実行コストが増加します。順序が重要でない場合は、中間操作unordered()
使用して保存を無効にし、生産性を向上させることができます。
コレクション.ParallelStream() .sorted () .unordered () .collect ( コレクター .toList ());
↥ トップに戻る
Java Virtual Machine (JVM) は、Java バイトコード (.class ファイル) を実行できる実行環境を提供する仕様です。 JVM はプラットフォームです。 JVM は「仮想」マシンまたはプロセッサとして機能します。 Java のプラットフォーム独立性は、主に Java 仮想マシン (JVM) で構成されます。 JVM は、特定の命令の長さやプラットフォーム (オペレーティング システム) のその他の特性を認識しているため、これが可能になります。
JVM はプラットフォームに依存しません。 Java仮想マシン(JVM)は、Javaファイル(.Classファイル)を実行する環境を提供します。したがって、最終的にはカーネルに依存し、カーネルはOS(オペレーティングシステム)ごとに異なります。 JVM は、バイトコードを特定のコンピューターの機械語に変換することと、対応する機械語命令を実際に実行することの両方に使用されます。
↥ トップに戻る
ジャストインタイム (JIT) コンパイラは、実行時にバイトコードをネイティブ マシン コードにコンパイルすることにより、Java アプリケーションのパフォーマンスを向上させるランタイム環境のコンポーネントです。
Java プログラムはクラスで構成されており、クラスには、さまざまなコンピューター アーキテクチャ上の JVM によって解釈できるプラットフォームに依存しないバイトコードが含まれています。実行時に、JVM はクラス ファイルをロードし、個々のバイトコードのセマンティクスを決定し、適切な計算を実行します。解釈中にプロセッサとメモリの使用量が増えるため、Java アプリケーションの実行速度がネイティブ アプリケーションよりも遅くなります。 JIT コンパイラは、実行時にバイトコードをネイティブ マシン コードにコンパイルすることにより、Java プログラムのパフォーマンスの向上に役立ちます。 JIT コンパイラはデフォルトで有効になっています。メソッドがコンパイルされると、JVM はそのメソッドのコンパイルされたコードを解釈する代わりに直接呼び出します。
↥ トップに戻る
Java ClassLoader は、Java クラスを Java 仮想マシンに動的にロードする Java ランタイム環境の一部です。 Javaコードはjavacコンパイラによってクラスファイルにコンパイルされ、JVMはクラスファイルに記述されたバイトコードを実行することでJavaプログラムを実行します。 ClassLoader は、ファイル システム、ネットワーク、またはその他のソースからクラス ファイルをロードします。
クラスローダーの種類:
1. ブートストラップ クラス ローダー:
rt.jar およびその他のコア クラスから標準の JDK クラス ファイルをロードします。 jre/lib/rt.jar からクラス ファイルをロードします。たとえば、java.lang パッケージ クラスです。
2. 拡張クラスローダー:
通常はJAVA_HOME/lib/ext
ディレクトリ、または他のディレクトリ (java.ext.dirs) から JDK 拡張機能からクラスを直接ロードします。
3. システムクラスローダー:
CLASSPATH 環境変数からアプリケーション固有のクラスをロードします。 -cp または classpath コマンド ライン オプションを使用してプログラムを呼び出すときに設定できます。
↥ トップに戻る
1.JDK :
Java Development Kit は Java 環境のコアコンポーネントであり、Java プログラムのコンパイル、デバッグ、実行に必要なすべてのツール、実行可能ファイル、バイナリを提供します。
2.JVM :
JVM は、バイト コードをマシン固有のコードに変換する役割を果たします。 JVM はプラットフォームにも依存しており、メモリ管理、ガベージ コレクション、セキュリティなどのコア Java 機能を提供します。JVM はカスタマイズ可能で、Java オプションを使用してカスタマイズできます。たとえば、JVM に最小メモリと最大メモリを割り当てることができます。 JVM は、基盤となるオペレーティング システムやマシン ハードウェアに依存しないインターフェイスを提供するため、仮想と呼ばれます。
2.JRE :
Java ランタイム環境は、Java プログラムを実行するためのプラットフォームを提供します。 JRE は、あらゆるプログラムを正常に実行するための JVM、Java バイナリ、およびその他のクラスで構成されています。
↥ トップに戻る
1. Java ヒープ スペース:
Java ヒープ領域は、オブジェクトおよびJRE クラスにメモリを割り当てるために Java ランタイムによって使用されます。オブジェクトを作成するときは、常にヒープ領域に作成されます。
ガベージ コレクションはヒープ メモリ上で実行され、参照のないオブジェクトによって使用されているメモリを解放します。ヒープ スペース内に作成されたオブジェクトにはグローバル アクセスがあり、アプリケーションのどこからでも参照できます。
2. Java スタック メモリ:
Java のスタックは、メソッド、ローカル変数、および参照変数を含むメモリのセクションです。ローカル変数はスタック内に作成されます。
スタック メモリは常に LIFO (Last-In-First-Out) 順序で参照されます。メソッドが呼び出されるたびに、メソッドのスタック メモリに新しいブロックが作成され、ローカル プリミティブ値とメソッド内の他のオブジェクトへの参照が保持されます。
メソッドが終了するとすぐに、ブロックは未使用になり、次のメソッドで使用できるようになります。スタック メモリのサイズはヒープ メモリに比べて非常に小さいです。
違い:
パラメータ | スタックメモリ | ヒープスペース |
---|---|---|
応用 | スタックは、スレッドの実行中に一度に 1 つずつ部分的に使用されます。 | アプリケーション全体が実行時にヒープ領域を使用します |
サイズ | スタックには OS に応じてサイズ制限があり、通常はヒープよりも小さくなります | ヒープのサイズ制限はありません |
ストレージ | プリミティブ変数とヒープ領域に作成されたオブジェクトへの参照のみを格納します。 | 新しく作成されたオブジェクトはすべてここに保存されます |
注文 | Last-in First-out (LIFO) メモリ割り当てシステムを使用してアクセスされます。 | このメモリには、若い世代、古い世代または Tenured 世代、永続的な世代などの複雑なメモリ管理手法を介してアクセスされます。 |
人生 | スタック メモリは、現在のメソッドが実行されている間のみ存在します。 | ヒープ領域はアプリケーションが実行されている限り存在します。 |
効率 | ヒープと比較すると、割り当てが比較的高速です | スタックと比較すると割り当てが遅い |
割り当て/割り当て解除 | このメモリは、メソッドが呼び出されたときと返されたときに自動的に割り当てられ、割り当てが解除されます。 | 新しいオブジェクトが作成されるときにヒープ領域が割り当てられ、参照されなくなったときに Gargabe Collector によって割り当てが解除されます。 |
↥ トップに戻る
JVM は、Java バイトコードを取得し、そのバイト コード (行ごと) を機械が理解できるコードに変換するプログラムです。 JVM は、いくつかの特定の種類の操作を実行します。
コードのロード
コードの検証
コードの実行
ユーザーに実行環境を提供します
JVM によって割り当てられるメモリ領域の種類:
1. クラスローダー: クラスローダーは、クラス ファイルをロードするために使用される JVM のサブシステムです。
2. クラス(メソッド)領域: クラス(メソッド)領域には、実行時定数プール、フィールドおよびメソッドのデータ、メソッドのコードなどのクラスごとの構造が格納されます。
3. ヒープ: オブジェクトが配置される実行時のデータ領域です。
4. スタック: Java スタックはフレームを格納します。ローカル変数と部分的な結果を保持し、メソッドの呼び出しと戻りに役割を果たします。各スレッドにはプライベート JVM スタックがあり、スレッドと同時に作成されます。
5. プログラム カウンタ レジスタ: PC (プログラム カウンタ) レジスタ。これには、現在実行されている Java 仮想マシン命令のアドレスが含まれます。
6. ネイティブ メソッド スタック: アプリケーションで使用されるすべてのネイティブ メソッドが含まれます。
↥ トップに戻る
プリミティブ データ型を同等の Wrapper 型に自動的に変換することはボックス化として知られ、その逆の操作はアンボックス化として知られています。
例:オートボクシング
/** * オートボクシング */class BoxingExample { public static void main(String args[]) { int a = 50; 整数 a2 = 新しい整数(a); // ボクシング整数 a3 = 5; // ボクシング System.out.println(a2 + " " + a3); } }
例:開梱する
/** * ボックス化解除 */class UnboxingExample { public static void main(String args[]) { Integer i = new Integer(50); int a = i; System.out.println(a); } }
↥ トップに戻る
1. トランジェント:
transient 修飾子は、クラスのインスタンスをシリアル化するときにフィールドを除外するように Java オブジェクト シリアル化サブシステムに指示します。オブジェクトが逆シリアル化されると、フィールドはデフォルト値に初期化されます。つまり、参照型の場合は null、プリミティブ型の場合は 0 または false。
例:
/** * Transient */public transient int limit = 55; // 永続化されませんpublic int b; // 永続化されます
2. 揮発性:
volatile 修飾子は、フィールドへの書き込みは常にメモリに同期してフラッシュする必要があり、フィールドの読み取りは常にメモリから読み取る必要があることを JVM に指示します。これは、ネイティブまたは標準ライブラリベースの同期を使用せずに、マルチスレッド アプリケーションで揮発性としてマークされたフィールドに安全にアクセスして更新できることを意味します。
例:
/** * Volatile */public class MyRunnableimplements Runnable { private volatile boolean active; public void run() { active = true; while (アクティブ) { } public void stop() { アクティブ = false; } }
↥ トップに戻る
アサーションを使用すると、プログラム内で行われた仮定の正しさをテストできます。アサーションは、Java のassert ステートメントを使用して実現されます。
アサーションの実行中は、それが真実であると信じられます。失敗すると、JVM はAssertionError
というエラーをスローします。主に開発時のテスト目的で使用されます。
Assert ステートメントはブール式とともに使用され、2 つの異なる方法で記述できます。
// 最初の方法のアサート式;// 2 番目の方法アサート式 1 : 式 2;
例:
/** * アサーション */public class 例 { public static void main(String[] args) { int age = 14; 年齢 <= 18 をアサート:「投票できません」; System.out.println("投票者の年齢は " + 年齢です); } }
↥ トップに戻る
1. 最終変数:
最終変数は定数にすぎません。最終変数が初期化されると、その値を変更することはできません。
例:
/** * 最終変数 */class デモ {final int MAX_VALUE = 99; void myMethod() { MAX_VALUE = 101; public static void main(String args[]) { デモ obj = new Demo(); obj.myMethod(); } }
出力
スレッド「メイン」java.lang.Error での例外: 未解決のコンパイルの問題: 最後のフィールド Demo.MAX_VALUE は、beginerbook.com.Demo.myMethod(Details.java:6)、beginegersbook.com.Demo.main(Details.java:10) では割り当てることができません。
2. 空白の最終変数:
宣言時に初期化されていない最終変数は、空の最終変数と呼ばれます。クラスのコンストラクターで空の最終変数を初期化する必要があります。そうしないと、コンパイル エラーがスローされます (エラー: variable MAX_VALUE might not have been initialized
)。
例:
/** * 空白の最終変数 */class Demo { // 空白の最終変数 Final int MAX_VALUE; Demo() { // コンストラクターで初期化する必要があります MAX_VALUE = 100; void myMethod() { System.out.println(MAX_VALUE); public static void main(String args[]) { デモ obj = new Demo(); obj.myMethod(); } }
出力
100
3. 最終的な方法:
最終メソッドをオーバーライドすることはできません。つまり、サブクラスは親クラスの最終メソッドを問題なく呼び出すことができますが、それをオーバーライドすることはできません。
例:
/** * 最終メソッド */class XYZ { Final void Demon() { System.out.println("XYZ クラス メソッド"); } }class ABC extends XYZ { void Demon() { System.out.println("ABC クラス メソッド"); } public static void main(String args[]) { ABC obj = new ABC(); obj.demo(); } }
↥ トップに戻る
プリミティブ型または文字列が定数として定義されており、その値がコンパイル時にわかっている場合、コンパイラはコード内のあらゆる場所の定数名をその値に置き換えます。これはコンパイル時定数と呼ばれます。
コンパイル時定数は次のようにする必要があります。
決勝戦を宣言
プリミティブまたは文字列
宣言内で初期化される
定数式で初期化
コンパイラはその値を事前に認識しており、実行時に変更できないことも認識しているため、これらはコンパイル時に実際の値に置き換えられます。
プライベートファイナル int x = 10;
↥ トップに戻る
アクセス指定子/修飾子は、クラス、コンストラクター、変数、メソッド、またはデータ メンバーのスコープを制限するのに役立ちます。
Java で使用できるアクセス修飾子は 4 種類あります。
default
– キーワードは必要ありません。クラス、コンストラクター、変数、メソッド、またはデータメンバーがアクセス指定子なしで宣言されている場合、デフォルトのアクセススコープを持ちます。つまり、同じパッケージ内でのみアクセス可能です。
private
- private として宣言すると、アクセス範囲はそれを囲んでいるクラス内に制限されます。
protected
- 保護されていると宣言された場合、アクセス範囲は、囲んでいるクラス、同じパッケージのサブクラス、および他のパッケージに制限されます。
public
- public として宣言されると、プログラム内のどこからでもアクセスできます。
... /* データ メンバー変数 */ String firstName="Pradeep"; /* デフォルトのスコープ */ protected isValid=true; /* 保護されたスコープ */ private String otp="AB0392"; /* プライベート スコープ */ public int id = 12334; /* パブリックスコープ */ ... ... /* データ メンバー関数 */ String getFirstName(){ return this.firstName; } /* デフォルトのスコープ */ protected boolean getStatus(){this.isValid;} /* protected スコープ */ private voidgenerateOtp(){ /* プライベート スコープ */ this.otp = this.hashCode() << 16; }; public int getId(){ this.id を返す; } /* パブリックスコープ */ ... .../* 内部クラス */ クラス A{} /* デフォルトのスコープ */ 保護されたクラス B{} /* 保護されたスコープ */ プライベート クラス C{} /* プライベート スコープ */ パブリック クラス D{} /* パブリック スコープ*/ ...
↥ トップに戻る
Java では、すべての非静的メソッドはデフォルトで仮想関数です。キーワードfinal
でマークされたメソッド (オーバーライドできない) と、継承されないprivate methods
プライベート メソッド) のみが非仮想です。
例:インターフェイスを使用した仮想機能
/** * インターフェイス内の関数はオーバーライドされるように設計されているため、* 関数 applyBrakes() は仮想です。 **/interface Bicycle { void applyBrakes(); }class ACMEBicycleimplements Bicycle { public void applyBrakes() { // ここでは applyBrakes() を実装します。 System.out.println("Brakes apply"); // 関数 } }
↥ トップに戻る
ネイティブ メソッドは、実装も C/C++ などの別のプログラミング言語で記述された Java メソッド (インスタンス メソッドまたはクラス メソッド) です。さらに、ネイティブとしてマークされたメソッドは本体を持つことができず、セミコロンで終わる必要があります。
メイン.java:
パブリッククラスMain {パブリックネイティブint intMethod(int i); public static void main(String[] args) { System.loadLibrary("Main"); System.out.println(new Main().intMethod(2)); } }
Main.c:
#include <jni.h>#include "Main.h"JNIEXPORT jint JNICALL Java_Main_intMethod( JNIEnv *env, jobject obj, jint i) { return i * i; }
コンパイルして実行します。
javac Main.javajavah -jni Mainingcc -shared -fpic -o libMain.so -I${JAVA_HOME}/include -I${JAVA_HOME}/include/linux Main.cjava -Djava.library.path=。主要
出力
4
↥ トップに戻る
メソッドが静的として宣言されている場合、そのメソッドはクラスのオブジェクトに属するのではなく、クラスのメンバーになります。クラスのオブジェクトを作成せずに呼び出すことができます。静的メソッドには、クラスの静的データ メンバーにアクセスする機能もあります。
静的メソッドにはいくつかの制限があります
静的メソッドでは、非静的データ メンバーを使用したり、非静的メソッドを直接呼び出したりすることはできません。
this
とsuper
静的コンテキストでは使用できません。
静的メソッドは静的型データ(静的型インスタンス変数)のみにアクセスできます。
静的メソッドを呼び出すためにクラスのオブジェクトを作成する必要はありません。
静的メソッドはサブクラスでオーバーライドできません
例:
/** * 静的メソッド */class Parent { static void display() { System.out.println("スーパークラス"); } } public class Example extends Parent { void display() // display() をオーバーライドしようとしています { System.out.println("Sub class"); } public static void main(String[] args) { 親 obj = new Example(); obj.display(); } }
これによりコンパイル時エラーが発生します。出力は次のとおりです-
Example.java:10: エラー: 例の display() は Parentvoid display() の display() をオーバーライドできません // display() をオーバーライドしようとしています ^オーバーライドされたメソッドは static1 エラーです
↥ トップに戻る
ラムダ式を使用する場合の構造と特徴は何ですか?ラムダは、個別の変数に分割して、プログラムのさまざまな場所で繰り返し呼び出すことができる一連の命令です。
ラムダ式の基礎は、矢印->
を表すラムダ演算子です。この演算子はラムダ式を 2 つの部分に分割します。左側には式パラメータのリストが含まれ、右側は実際にラムダ式の本体を表し、すべてのアクションが実行されます。
ラムダ式はそれ自体では実行されませんが、関数インターフェイスで定義されたメソッドの実装を形成します。関数インターフェイスには、実装せずにメソッドを 1 つだけ含める必要があることが重要です。
インターフェイス 操作可能 { int Calculate ( int x , int y ); } public static void main ( String [] args) { 操作可能な操作 = (x, y) - > x + y; int 結果 = 操作.計算 ( 10 , 20 ); System.out.println (結果); // 30 }
実際、ラムダ式は、ある意味、Java で以前に使用されていた内部匿名クラスの短縮形です。
遅延実行ラムダ式- プログラムの 1 か所で 1 回定義され、必要に応じてプログラムの任意の場所で何度でも呼び出されます。
ラムダ式のパラメータは、関数型インターフェイス メソッドのパラメータに型が対応している必要があります。
Operation = ( int x, int y) - > x + y;// ラムダ式自体を記述する場合、パラメーターの型を指定することはできません: (x, y) - > x + y;// メソッドの場合パラメータを受け入れない場合は、空の括弧が書き込まれます。例: () - > 30 + 20 ;// メソッドがパラメータを 1 つだけ受け入れる場合は、括弧を省略できます: n - > n * n;
後続のラムダ式は値を返す必要はありません。
インターフェイス Printable { void print( String s ); } public static void main ( String [] args) { 印刷可能なプリンター = s - > System.out.println(s); printer.print("こんにちは、世界"); }// _ ブロック ラムダ式_ は中括弧で囲まれています。モジュラー ラムダ式は、ネストされたブロック、ループ内で使用したり、if ` switch ステートメントを設計したり、変数を作成したりすることができます。 d .ラムダ式をブロックする場合 - 式は値を返す必要があり、明示的に `statement return ステートメント ' :Operationable 操作 = ( int x, int y) - > { が適用されます。 if (y == 0 ) { 0 を返す ; } else { x / y を返します。 } };
ラムダ式をメソッドパラメータとして渡す
インターフェイス条件 { boolean isAppropriate ( int n ); }private static int sum ( int [] 数値, 条件条件) { int result = 0 ; for ( int i : 数値) { if (condition.isAppropriate(i)) { 結果 + = i; } 結果を返します。 } public static void main ( String [] args) { System.out.println(sum ( new int [] { 0 , 1 , 0 , 3 , 0 , 5 , 0 , 7 , 0 , 9 }, (n) - > n = 0 )); }
↥ トップに戻る
ラムダ式から外部スコープ変数へのアクセスは、匿名オブジェクトからのアクセスと非常に似ています。
不変 (事実上最終 - 必ずしも最終としてマークされているわけではない) ローカル変数。
クラスフィールド
静的変数。
実装された関数インターフェイスのデフォルト メソッドには、ラムダ式内でアクセスすることはできません。
↥ トップに戻る
クラス内に存在するメソッドがすでに必要な処理をすべて行っている場合は、メソッド参照機構 (メソッド参照) を使用して、このメソッドを直接渡すことができます。結果は、このメソッドを呼び出すラムダ式を定義した場合とまったく同じになります。
例:
プライベートインターフェイス Measurable { public int length(String string); } public static void main ( String [] args) { 測定可能な a = String::length; System.out.println(a.length("abc")); }
メソッド参照は、ラムダ式を使用するよりも効率的である可能性があります。さらに、型に関するより適切な情報がコンパイラーに提供されるため、既存のメソッドへの参照を使用するかラムダ式を使用するかを選択できる場合は、常にメソッド参照を使用する必要があります。
↥ トップに戻る
静的メソッドについて。
インスタンスごとのメソッド。
コンストラクターに。
↥ トップに戻る
ネストされた内部クラスは、外部クラスのプライベート インスタンス変数にアクセスできます。他のインスタンス変数と同様に、アクセス修飾子として、private、protected、public、default 修飾子を指定できます。
例:
/** * 内部クラス */class 外部 { クラス内部 { public void show() { System.out.println("入れ子になったクラス メソッド内"); } } } クラスメイン{ public static void main(String[] args) { アウター.インナー = 新しいアウター().ニューインナー(); in.show(); } }
サブクラスは、スーパークラスからメソッドを継承するクラスです。
例:
/** * サブクラス */クラスカー { //...} class HybridCar extends Car { //...}
↥ トップに戻る
1. 静的クラスのロード:
new
キーワードを使用してオブジェクトとインスタンスを作成することは、静的クラスの読み込みとして知られています。クラス定義の取得とオブジェクトのインスタンス化はコンパイル時に行われます。
例:
/** * 静的クラスの読み込み */class TestClass { public static void main(String args[]) { TestClass tc = new TestClass(); } }
2. 動的クラスのロード:
クラスの読み込みにはClass.forName()
メソッドを使用します。動的クラスのロードは、コンパイル時にクラスの名前が不明な場合に行われます。
例:
/** * 動的クラスの読み込み */Class.forName (String className);
↥ トップに戻る
1. ランタイムクラス:
java.lang.Runtimeクラスは Object クラスのサブクラスであり、Java ランタイム システムへのアクセスを提供します。メモリの可用性、ガベージ コレクターの呼び出しなどの実行時情報。
例:
/** * ランタイム クラス */public class RuntimeTest { static class Message extends Thread { public void run() { System.out.println(" Exit"); } public static void main(String[] args) { try { Runtime.getRuntime().addShutdownHook(new Message()); System.out.println(" プログラムが開始されました..."); System.out.println(" 5 秒ほど待ちます..."); Thread.sleep(5000); System.out.println(" プログラムが終了しました..."); } catch (例外 e) { e.printStackTrace(); } } }
2. システムクラス:
System クラスの目的は、システム リソースへのアクセスを提供することです。これには、標準入力、標準出力、エラー出力ストリーム、ミリ単位の現在時刻、アプリケーションの終了などへのアクセスが含まれます。
↥ トップに戻る
1。新しいキーワードの使用:
myobject object = new Myobject();
2。class.forname()の使用:
myobject object =(myobject)class.forname( "subin.rnd.myobject")。newInstance();
3。clone()の使用:
myobject AnotherObject = new Myobject(); myobject object =(myobject)anotherObject.clone();
4。オブジェクトの脱3を使用:
ObjectInputStream instream = new objectInputStream(AninputStream); myObject object =(myobject)instream.readObject();
topに戻ります
不変のオブジェクトは、変更されないオブジェクトです。 Javaの不変のオブジェクトは、そのすべてのフィールドを内部のプライベート最終フィールドである必要があります。セッターを実装してはなりません。すべてのフィールドに値を取るコンストラクターが必要です。
不変のオブジェクトの作成:
セッターメソッドを追加しないでください
すべてのフィールドを最終的およびプライベートと宣言します
フィールドが可変オブジェクトである場合、getterメソッドのためにその防御コピーを作成します
コンストラクターに渡された可変オブジェクトがフィールドに割り当てられた場合、その防御コピーを作成する必要があります
サブクラスがメソッドをオーバーライドすることを許可しないでください。
/** * Immutable Object */public class dateContainer {プライベート最終日付; public dateContainer(){this.date = new date(); } public date getDate(){return new date(date.getTime()); } }
topに戻ります
不変のクラスとは、オブジェクトが作成されると、コンテンツを変更できないことを意味します。 Javaでは、すべてのラッパークラス(Integer、Boolean、Byte、Shortなど)およびStringクラスは不可能です。
不変のクラスを作成するためのルール:
クラスは最終として宣言する必要があります
クラスのデータメンバーは最終として宣言する必要があります
パラメーター化されたコンストラクター
その中のすべての変数のゲッターメソッド
セッターなし
/** * Immutable Class */Public Final Class Employee {Final String PancardNumber; 公務員(String PancardNumber){this.pancardnumber = pancardnumber; } public string getPancardNumber(){return pancardnumber; } }
topに戻ります
Bootstrap ClassLoaderは、 Rt.Jarの標準のJDKクラスファイルをロードするために担当者であり、Javaのすべてのクラスローダーの親です。 Javaには、組み込みのクラスローダーには3つのタイプがあります。
1。Bootstrapクラスローダー: JDK内部クラスをロードし、通常はRt.jarおよびその他のコアクラスをロードします。たとえばJava.lang。*パッケージクラス
2。拡張機能クラスローダー: JDK拡張機能ディレクトリ、通常は$ java_home/lib/extディレクトリからクラスをロードします。
3.システムクラスローダー: -CPまたは-ClassPathコマンドラインオプションを使用してプログラムを呼び出す際に設定できる現在のクラスパスからクラスをロードします。
/** * classloader */import java.util.logging.level; import java.util.logging.logger; public classloadertest {public static void main(string args []){try {//このクラスシステムのクラスローダーを印刷する.out.println( "classloader:" + classloadertest.class.getClassLoader()); //拡張機能クラスLoader class.fornameを使用してこのクラスを再度ロードしようとしています(「明示的にロードクラス」、true、classloadertest.class.getClassLoader()。getParent()); } catch(classNotFoundException ex){logger.getLogger(classLoadErtest.class.getName())。log(level.severe、null、ex); } } }
topに戻ります
Javaでオブジェクトを作成するさまざまな方法
新しいキーワードの使用:
class objectCreationExample {string owner; } public class mainclass {public static void main(string [] args){//ここで、新しいkeywordobjectcreationexampleを使用してjbtのオブジェクトを作成していますobj = new objectcreationexample(); } }
新しいインスタンスの使用(反射)
class createObjectClass {static int j = 10; createObjectClass(){i = j ++; } int i; @overridepublic string toString(){return "value of i:" + i; } } class mainclass {public static void main(string [] args){try {class cls = class.forname( "CreateObjectClass"); CreateObjectClass OBJ =(CreateObjectClass)Cls.NewInstance(); Create ObjectClass OBJ1 =(CreateObjectClass)Cls.Newinstance (); system.out.println(obj); system.out.println(obj1); } catch(classNotFoundException e){e.printstacktrace(); } catch(instantiationexception e){e.printstacktrace(); } catch(Illegalaccessexception e){e.printstacktrace(); } } }
クローンの使用:
クラスCreateObjectWithCloneはcloneable {@overrideprotected object clone()を実装しますclonenotsupportedexception {return super.clone(); } int i; static int j = 10; create objectwithclone(){i = j ++; } @overridepublic string toString(){return "of i:" + i; } } class mainclass {public static void main(string [] args){create objectwithclone obj1 = new CreateObjectWithClone(); system.out.println(obj1); try {createObjectwithClone obj2 =(create objectwithclone)obj1.clone(); system.out。 println(obj2); } catch(clonenotsupportedexception e){e.printstacktrace(); } } }
ClassLoaderを使用します
class CreateObjectWithClassLoader {static int j = 10; CreateObjectWithClassLoader(){i = J ++; } int i; @overridepublic string toString(){return "value of i:" + i; } } public class mainclass {public static void main(string [] args){create objectwithclassloader obj = null; try {obj =(create objectwithclassloaser)new MainClass()。getClass() .getClassLoader()。loadClass( "CreateObjectWithClassLoader")。newInstance(); //完全に適格なクラス名を使用する必要があります。 } catch(instantiationexception e){e.printstacktrace(); } catch(Illegalaccessexception e){e.printstacktrace(); } catch(classNotFoundException e){e.printstacktrace(); } system.out.println(obj); } }
topに戻ります
オブジェクトクラスは、デフォルトでJavaのすべてのクラスの親クラスです。
方法 | 説明 |
---|---|
パブリックファイナルクラスgetClass() | このオブジェクトのクラスクラスオブジェクトを返します。さらに、クラスクラスを使用して、このクラスのメタデータを取得できます。 |
public int hashcode() | このオブジェクトのハッシュコード番号を返します。 |
パブリックブールエコール(オブジェクトOBJ) | 指定されたオブジェクトをこのオブジェクトと比較します。 |
保護されたオブジェクトclone()は、cloneNotsupportedexceptionをスローします | このオブジェクトの正確なコピー(クローン)を作成して返します。 |
public string toString() | このオブジェクトの文字列表現を返します。 |
パブリックファイナルボイドnotify() | このオブジェクトのモニターを待って、単一のスレッドを目覚めさせます。 |
パブリックファイナルボイドnotifyall() | このオブジェクトのモニターを待って、すべてのスレッドを目覚めさせます。 |
パブリックファイナルボイドウェイ(長いタイムアウト)が中断されたエクセプトをスローします | 別のスレッドが通知されるまで、現在のスレッドが指定されたミリ秒を待機します(notify()またはnotifyall()メソッド)。 |
パブリックファイナルボイド待機(Long Timeout、int nanos)が中断されたexceptionをスローします | 別のスレッドが通知されるまで、現在のスレッドは指定されたミリ秒とナノ秒を待機します(notify()またはnotifyall()メソッド)。 |
パブリックファイナルボイドウェイト()スローが中断されたエクセプトをスローします | 別のスレッドが通知されるまで、現在のスレッドが待機します(notify()またはnotifyall()メソッドを呼び出します)。 |
保護されたvoid finalize()スローがスロー可能 | オブジェクトがガベージを収集する前に、ゴミコレクターによって呼び出されます。 |
topに戻ります
オプションの値Optional
値null
含む場合と含まないオブジェクトのコンテナです。このようなラッパーは、便利な予防手段です