このブログでは、Java での OOP の概念の基本について学習します。 オブジェクト指向プログラミングは、継承、抽象化、ポリモーフィズムなど、さまざまな種類の概念を提供するモデルです。これらの概念は、プログラムに実世界のエンティティを実装することを目的としており、セキュリティを損なうことなくそれらを再利用するための作業メソッドと変数を作成します。 最も広く使用されている重要なオブジェクト指向プログラミング言語の多くには、Java、C++、C#、JavaScript、Python、Ruby、Perl、Smalltalk などがあります。

OOPの概念とは何ですか？

オブジェクト指向プログラミングは Javaプログラミング、クラスとオブジェクトを使用してプログラムを設計するために使用されます。 OOP は、コードにアクセスするためのデータ制御として特徴付けることもできます。 このアプローチでは、プログラマーは データ・タイプ の データ構造 およびデータ構造に適用される操作。

JavaのOOPとは何ですか？ 

Javaのオブジェクト指向プログラミングは、Javaプログラムを効率的に定義することにより、コードの可読性と再利用性を向上させることです。 オブジェクト指向プログラミングの主な原則は次のとおりです。 抽象化、カプセル化、継承、およびポリモーフィズム。 これらの概念は、プログラムに実際のエンティティを実装することを目的としています。

JavaでのOOPの概念のリスト

• オブジェクト
• クラス
• オブジェクト 
• CLASS
• 抽象化
• 継承 
• ポリモーフィズム
• カプセル化

オブジェクトとは何ですか？  

オブジェクトは常に、Java またはその他の言語のクラスから作成されたクラスのインスタンスと呼ばれます。 それらには状態と動作があります。

これらのオブジェクトは、常に実世界で見つかったもの、つまり実体に対応しています。 そのため、これらはワールドのランタイム エンティティとも呼ばれます。 これらは自己完結型で、データを有用にするメソッドとプロパティで構成されています。 オブジェクトは、物理データと論理データの両方にすることができます。 アドレスが含まれており、メモリ内のスペースを占有します。 オブジェクトの例としては、犬、椅子、木などがあります。 

動物を物として扱うとき、色、名前、品種などの状態と、食べる、尻尾を振るなどの行動があります。

My bookというクラスを作成し、クラス名の後にオブジェクト名を指定し、キーワードnewを使用するとします。

オブジェクトの例1：

Public class Mybook {
int x=10;
Public static void main (String args []) {
Mybook Myobj= new Mybook ();
System.out.println(MyObj.x);
}
} 

上記の例では、新しいオブジェクトが作成され、本の数である可能性のあるxの値が返されます。

Mybook Myobj = new Mybook（）;

 これは、オブジェクトの作成に使用されるステートメントです。

System.out.println（Myobj.x）;

このステートメントは、オブジェクトのxの値を返すために使用されます。

同じクラスに複数のオブジェクトを作成し、XNUMXつのクラスで作成して、別のクラスでアクセスすることもできます。 このメソッドは、クラスをより適切に編成するために使用され、Javaファイルの名前とクラス名は同じままであることを常に覚えておいてください。 

例2：

次の例は、同じクラスで複数のオブジェクトを作成する方法と、別のクラスからそれらにアクセスする方法を示しています。

• Mybook.java

Public class Mybook {
int x=10;
int y=8;
} 

• カウント.java

Class Count {
Public static void main (String [] args)
{
Mybook myobj1 = new myobj1(); Mybook myobj2 = new myobj2(); System.out.println (myobj1.x);
System.out.println (myobj2.y);
}
} 

このプログラムをコンパイルすると、結果はそれぞれ10と8になります。

クラスとは何ですか？

クラスは、オブジェクトを作成するためのオブジェクトコンストラクターのようなものです。 オブジェクトのコレクションはクラスと呼ばれます。 クラスは論理量と呼ばれます。 クラスはメモリ内のスペースを消費しません。 クラスは、オブジェクトのテンプレートとも呼ばれます。 クラスには、フィールド、メソッド、コンストラクターのメンバーがあります。 クラスには、静的初期化子とインスタンス初期化子の両方があります。

クラス宣言は次のもので構成されます。

1. 修飾子: これらは、パブリック アクセスまたはデフォルト アクセスのいずれかです。
2. クラス名： 頭文字。
3. スーパークラス： クラスはXNUMXつの親のみを拡張（サブクラス）できます。
4. インターフェース： クラスは複数のインターフェースを実装できます。
5. ボディ： 中かっこで囲まれた本体、{}。

classキーワードは、クラスを作成するために使用されます。 クラス定義の簡略化された一般的な形式を以下に示します。

class classname {
type instance variable 1;
type instance variable 2;
.
.
.
type instance variable n;
type methodname 1 (parameter list) {
// body od method }
type methodname 2 (parameter list) {
// body od method }
type methodnamen (parameter list) {
// body od method } } 

クラス内で定義された変数またはデータは、インスタンス変数と呼ばれます。 コードは常にメソッドに含まれています。 したがって、クラス内で定義されたメソッドと変数は、クラスのメンバーと呼ばれます。 すべてのメソッドは main () と同じ形式を持ち、これらのメソッドは static または public として指定されていません。 

抽象化とは何ですか？  

抽象化は、必要な情報のみを表示し、不要な情報を隠すプロセスです。 抽象化の主な目的はデータの隠蔽であると言えます。 抽象化とは、多数のデータからデータを選択して必要な情報を表示することを意味し、プログラミングの複雑さと労力を軽減するのに役立ちます。  

抽象クラスと抽象メソッドもあります。 抽象クラスは、XNUMX つ以上の抽象メソッドを宣言するクラスのタイプです。 抽象メソッドは、メソッド定義はあるが実装がないメソッドです。 データ抽象化を使用してオブジェクトをモデル化すると、同じデータ セットをさまざまなアプリケーション (抽象クラス、ジェネリック型の動作、オブジェクト指向プログラミング階層) で使用することもできます。 抽象メソッドは、XNUMX つ以上のサブクラスが同じタスクを異なる方法および異なる実装で実行する場合に使用されます。 抽象クラスは、抽象メソッドと通常のメソッドの両方のメソッドを持つことができます。

次に、抽象化に関連する例を見てみましょう。

学生アプリケーションを作成し、学生に関する情報を収集するよう依頼するとします。

以下の情報を収集します。  

• 名前  
• CLASS
• 住所
• ドブ
• 父の名前
• お母さんの名前など。 

申請書に記入するために収集したすべての情報が必要なわけではありません。 そのため、アプリケーションに記入するために必要なデータを選択します。 したがって、大規模なデータからデータ、学生情報を取得、削除、および選択しました。 このプロセスは、おっと概念の抽象化として知られています。

抽象クラスの例：

//abstract parent class Abstract class animal { //abstract method public abstract void sound ( ) ; } Public class lion extends animal { Public void sound ( ) {
System.out.println (“ roar “ );
}
public Static void main ( String args [ ] ) { animal obj = new lion ( );
obj. sound ();
}
} 

出力： 
とどろき

継承とは何ですか？

継承は、あるオブジェクトが別のオブジェクトのプロパティを取得/継承する方法であり、継承は階層分類もサポートします。 この背後にある考え方は、既存のクラスに基づいて構築された新しいクラスを作成できることです。つまり、既存のクラスから継承する場合、親クラスのメソッドとフィールドを再利用できます。 継承は親子関係を表します。 この概念の詳細については、 Javaコースでの無料継承.

たとえば、クジラは海洋動物の分類の一部であり、哺乳類のクラスの一部であり、そのクラスの動物に分類されます。 階層分類、つまりトップダウン分類を使用します。 哺乳類などのより具体的なクラスの動物について説明したい場合、それらは歯などのより具体的な属性を持ちます。 変温動物、温血動物など。これは動物のサブクラスに分類されますが、動物はスーパークラスに分類されます。 サブクラスは、スーパークラスのプロパティを継承するクラスです。 これは、派生クラスとも呼ばれます。 スーパークラスは、サブクラスがプロパティを継承する基本クラスまたは親クラスです。

継承は主にメソッドのオーバーライドとRに使用します。

クラスを継承するには、extendキーワードを使用します。

継承には、シングル、マルチレベル、マルチプル、ハイブリッド、階層のXNUMXつのタイプがあります。 

• シングルレベル  

このXNUMXつのクラスでは、つまり、派生クラスはその親クラスからプロパティを継承します。 これにより、コードの再利用が可能になり、コードに新しい機能が追加されます。 例：クラスbはクラスaからプロパティを継承します。

クラスAは基本クラスまたは親クラスであり、クラスbは派生クラスです。

構文： 

Class a {
…
}
Class b extends class a {
…
} 

• マルチレベル

このXNUMXつのクラスは、別のクラスから派生した別のクラスから派生します。つまり、このクラスには複数の親クラスがあるため、マルチレベル継承と呼ばれます。

構文：

Class a {
….
}
Class b extends class a {
….
}
Class c extends class b {
… } 

• 階層レベル 

この XNUMX つの親クラスに XNUMX つ以上の派生クラスがあるか、XNUMX つ以上の子クラスに XNUMX つの親クラスがあると言えます。

構文：

Class a {
…
} Class b extends class a {
..
}
Class c extends class a {
..
} 

• ハイブリッド継承

これは多重継承と多重レベル継承の組み合わせであり、Java では多重継承はサポートされていません。多重継承はあいまいさにつながり、このタイプの継承はインターフェイスを介してのみ実現できます。

クラス a がクラス b とクラス c の親クラスまたは基本クラスであり、クラス b とクラス c がクラス d の親クラスまたは基本クラスであるとします。 クラス b とクラス c はクラス a から派生したクラスであり、クラス d はクラス b とクラス c から派生したクラスです。

次のプログラムは、add というスーパークラスと sub というサブクラスを作成し、extend キーワードを使用してサブクラス add を作成します。

// a simple example of inheritance //create a superclass
Class Add {
int my;
int by;
void setmyby (int xy, int hy) {
my=xy;
by=hy;
}
}
/create a sub class
class b extends add {
int total;
void sum () {
public Static void main (String args [ ] ) {
b subOb= new b ( );
subOb. Setmyby (10, 12);
subOb. Sum ( ) ;
System.out.println(“total =” + subOb. Total);
}
} 

次のように出力されます– 合計= 22

ポリモーフィズムとは何ですか？

ポリモーフィズムとは、多くの形式を指すか、単一のアクションをさまざまな方法で実行するプロセスです。 継承によって互いに関連する多くのクラスがある場合に発生します。 ポリモーフィズムには、コンパイル時ポリモーフィズムと実行時ポリモーフィズムの XNUMX 種類があります。 コンパイル時のポリモーフィズムの例の XNUMX つは、Java で静的メソッドをオーバーロードする場合です。 動的メソッド ディスパッチとも呼ばれるランタイム ポリモーフィズムは、オーバーライドされたメソッドの呼び出しがコンパイル時ではなく実行時に解決されるメソッドです。 このメソッドでは、オーバーライドされたメソッドは常に参照変数を介して呼び出されます。 メソッドのオーバーロードとメソッドのオーバーライドを使用することで、ポリモーフィズムを実行できます。 一般に、ポリモーフィズムの概念は、XNUMX つのインターフェイスと複数のメソッドとして表現されることがよくあります。 これにより、同じインターフェイスを一般的なアクション クラスとして使用できるようになるため、複雑さが軽減されます。 

例：

public class Bird {
…
Public void sound ( ) {
System.out.println ( “ birds sounds “ );
}
}
public class pigeon extends Bird {
…
@override
public void sound ( ) {
System.out.println( “ cooing ” ) ;
}
}
public class sparrow extends Bird ( ) {
….
@override Public void sound ( ){
System.out.println( “ chip ” ) ;
}
} 

上記の例では、一般的なアクション音（）が表示されますが、同じアクションを実行するにはさまざまな方法があります。 これは、ポリモーフィズムを示す例のXNUMXつです。

Javaのポリモーフィズムは、次のXNUMXつのタイプに分類できます。

1. 静的/コンパイル時のポリモーフィズム
2. 動的/ランタイムポリモーフィズム

Javaのコンパイル時ポリモーフィズムとは何ですか？

Java のコンパイル時ポリモーフィズムは、静的ポリモーフィズムとも呼ばれます。 メソッドのオーバーロードによって達成されるコンパイル時に解決されます。

Javaのランタイムポリモーフィズムとは何ですか？

Java のランタイム ポリモーフィズムは動的バインディングとも呼ばれ、コンパイル時ではなく実行時に動的に解決されるオーバーライドされたメソッドを呼び出すために使用されます。 

カプセル化とは何ですか？

カプセル化は、OOPの概念の概念のXNUMXつです。 これは、データとコードをXNUMXつのユニットにバインドし、外部からの干渉や誤用から両方を保護するプロセスです。 このプロセスでは、データは他のクラスから隠されており、現在のクラスのメソッドを介してのみアクセスできます。 したがって、データの非表示とも呼ばれます。 カプセル化は、外部からのコードやデータへのアクセスを防ぐ保護ラッパーとして機能します。 これらは、明確に定義されたインターフェースを介して制御されます。 

カプセル化は、変数をプライベートとして宣言し、パブリック セッター メソッドとゲッター メソッドを提供して変数値を変更および表示することによって実現されます。 カプセル化では、クラスのフィールドは読み取り専用または書き込み専用になります。 この方法により、再利用性も向上します。 カプセル化されたコードは、単体テストのテストも簡単です。

例：

class animal {
// private field private int age;
//getter method Public int getage ( ) {
return age;
}
//setter method public void setAge ( int age ) {
this. Age = age;
}
}
class Main {
public static void main (String args []);
//create an object of person Animal a1= new Animal ();
//change age using setter A1. setAge (12);
// access age using getter System.out.println(“ animal age is ” + a1. getage ( ) );
}
} 

出力： 動物の年齢は12歳です

この例では、クラスの外部からアクセスできないageというプライベートフィールドを宣言しました。

年齢にアクセスするために、パブリックメソッドを使用しました。 これらのメソッドは、getterメソッドおよびsetterメソッドと呼ばれます。 年齢を非公開にすることで、クラス外からの不正アクセスを制限できます。 したがって、これはデータの隠蔽と呼ばれます。 

Javaでの結合

カップリング XNUMX つのクラス間の関係を指します。 あるオブジェクトまたはクラスが別のオブジェクトまたはクラスについて持っている知識を示します。 これは、XNUMX つのクラスがそのプロパティまたは動作を変更すると、他のクラスの依存する変更に影響を与えることを意味します。 したがって、これらの変更は、XNUMX つのクラス間の相互依存のレベルに依存します。 結合には、密結合と疎結合の XNUMX 種類があります。

• 密結合： あるクラスが別のクラスと強く相互に関連している場合、そのクラスと密結合していると言われます。 

public class College{
public void status() {
System.out.println("College is open today");
}
}
public class Student{
College obj = new College();
public void goToCollege() {
obj.status();
}
}

上記のコード例では、学生クラスは大学クラスに依存しています。 つまり、大学のクラスが変更されると、学生のクラスも変更される必要があります。 したがって、ここでは、学生クラスと大学クラスが互いに密接に結合されています。

• 緩い結合： あるクラスが別のクラスと弱く相互に関連している場合、そのクラスとの結合が緩いと言われます。 密結合よりも緩結合の方が適しています。 以下に示すように、クラスはインターフェースの助けを借りてこれを達成できます。 

public interface College{
void status();
}
class CollegeStatus1 implements College{
public void status() {
System.out.println("College is open monday to friday");
}
}
class CollegeStatus2 implements College{
public void status() {
System.out.println("College is open on saturday");
}
}
public class Student{
College obj = new CollegeStatus1();
public void goToCollege() {
obj.status();
}
}

上記のコード例では、CollegeStatus1とCollegeStatus2は緩く結合されています。 ここでは、学生クラスは、CollegeStatus1またはCollegeStatus2クラスと直接または緊密に結合されていません。 依存性注入メカニズムを適用することにより、緩い結合の実装が実現され、学生は大学のインターフェイスを実装した任意のクラスで大学に行くことができます。 さらに、それは、大学が土曜日に開いているときはいつでも、CollegeStatus2を使用できることを意味します。

Javaでの凝集度

Java Cohesionは、クラスのメソッドと属性が互いにどのように有意義かつ強力に関連しているか、およびシステムに対して明確に定義された単一のタスクの実行にどの程度焦点を合わせているかを測定します。 これは、クラスが単一の、焦点を絞った責任をどの程度持っているかを示すために使用されます。 コードの再利用性のために、よりまとまりのあるクラスを維持することをお勧めします。 凝集性の低いクラスは、メソッドとプロパティの間の論理的な関係が少ないため、維持するのが困難です。 単一の作業に集中できるように、非常にまとまりのあるクラスを用意することをお勧めします。

• 低凝集度： 次のコードには、Bookというクラスがあります。 ただし、クラスに対する焦点が絞られていない独立した属性とメソッドで構成されているため、まとまりが少なくなります。 このクラスには、本に関連する情報が含まれている必要があります。 したがって、人の名前と年齢の方法は、このクラスレスのまとまりを作ります。

class Book{
int price = 299; //related attribute
String name = "Sam"; //unrelated attribute
//related methods to Book class
public String author(String name) {
return name;
}
public String title(String subject) {
return subject;
}
public int id(int number) {
return number;
}
//unrelated methods to Book class
public int age(int age) {
return age;
}
}

• 高い凝集度： クラスに明確に定義された単一の目的またはタスクがある場合、それは非常にまとまりがあると言われます。 したがって、上記のサンプルコードでは、人物に関連する情報を削除すると、以下に示すように、クラスは非常にまとまりのあるものになります。

class Book{
int price = 299; //related attribute
//related methods to Book class
public String author(String name) {
return name;
}
public String title(String subject) {
return subject;
}
public int id(int number) {
return number;
}
}

Javaでの関連付け

アソシエーションは、オブジェクトの助けを借りて確立するXNUMXつの別々のクラス間の関係です。 XNUMXつ以上のオブジェクト間の関係を指定します。 関連付けは、XNUMX対XNUMX、XNUMX対多、多対XNUMX、および多対多にすることができます。 バスと乗客の関係を想定して、実際の例でこれを理解しましょう。 バスはXNUMX人のドライバー（XNUMX対XNUMX）のみを持つことができます。 多くの乗客が単一のバス（多対XNUMX）に関連付けることができます。 XNUMX人の乗客は、多くの異なるバス（XNUMX対多）に関連付けることができます。 また、多くの乗客は多くの異なるバス（多対多）に関連付けることができます。 あるオブジェクトは別のオブジェクトに関連付けられ、別のオブジェクトによって提供される機能とサービスを使用します。 

以下のコードを検討してください。

//class bus
class Bus
{
private String name;
// bus name
Bus(String name)
{
this.name = name;
}
public String getBusName()
{
return this.name;
}
} //passenger class
class Passenger
{ // passenger name
private String name;
// passenger seat id number
private int seatId;
Passenger(String name, int seatId)
{
this.name = name;
this.seatId = seatId;
}
public String getPassengerName()
{
return this.name;
}
public int getPassengerId()
{
return this.seatId;
}
} //Association between both the
//classes in the main method
class Demo
{
public static void main (String[] args)
{
Bus bus = new Bus("Shree Travels"); Passenger psg = new Passenger("Sneha", 52);
System.out.println(psg.getPassengerName() + " with seat number " + psg.getPassengerId()
+ " is a passenger of " + bus.getBusName());
}
}

出力：

座席番号52のSnehaはShreeTravelsの乗客です

説明：

上記の例では、XNUMXつの別々のクラスBusとPassengerが、クラスDemo内のオブジェクトを介して関連付けられています。 このように、関連付けの概念を使用して、XNUMXつの異なるクラス間の関係を確立できます。 バスは多くの乗客を乗せることができるので、XNUMX対多の関係です。

アソシエーションにはXNUMXつのタイプがあり、次のとおりです。
1.集約
2。 構図

XNUMXつについて詳しく説明しましょう。

アグリゲーション

Java Aggregationは弱い関連付けであり、他のオブジェクトを含むオブジェクト間の関係を表します。 これは、一部が全体なしで存在できる関係全体の一部を表します。 グループと個人の関係を例にとってみましょう。 個人は複数のグループに属することができます。 したがって、グループは複数の人を持つことができます。 ただし、Groupを削除しても、Personオブジェクトは破棄されません。 集約は、Has-A関係、一方向の関連付け、つまり一方向の関係を表します。 たとえば、グループに人を含めることはできますが、その逆は不可能であるため、一方向です。 このセクションでは、両方のエントリを個別に存続させることができます。つまり、一方のエンティティを終了しても、もう一方のエンティティには影響しません。 したがって、両方のオブジェクトは集約において独立しています。

次のコード例を検討します。

import java.util.*; //person class
class Person
{
private String name;
private int age ;
Person(String name, int age)
{
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
} /* Group class contains the list of person
Objects. It is associated with the person
class through its Object(s). */ //group class
class Group
{
private String groupName;
private List<Person> persons;
Group(String groupName, List<Person> persons)
{
this.groupName = groupName;
this.persons = persons;
}
} //main method
class Demo
{
public static void main (String[] args)
{ //creating objects of person class
Person a = new Person("Tanmay", 17);
Person b = new Person("Sam", 18);
Person c = new Person("Pitu", 19);
Person d = new Person("Khushi", 20);
//making a list of persons belongs to social welfare group
List<Person> p1 = new ArrayList<>();
p1.add(a);
p1.add(c);
//making a list of persons belongs to drama fest group
List<Person> p2 = new ArrayList<>();
p2.add(b);
p2.add(d);
//creating objects of group class
Group swGrp = new Group("Social Welfare", p1);
Group dfGrp = new Group("Drama Fest", p2);
//before deleting drama fest group
System.out.println("List of persons in Drama Fest group:");
for(Person p : p2) {
System.out.println("Person name: " + p.getName() + ", Age:" + p.getAge() + ", Group: Drama Fest");
}
//deleting drama fest group
dfGrp = null;
//after deleting drama fest group
//person list will not destroy
System.out.println("List of persons after deleting Drama Fest group:");
for(Person p : p2) {
System.out.println("Person name: " + p.getName() + ", Age: " + p.getAge());
}
}
}

出力：

ドラマフェストグループの人のリスト：

人物名：サム、年齢：18歳、グループ：ドラマフェスト

人物名：クシ、年齢：20歳、グループ：ドラマフェスト

ドラマフェストグループ削除後の人物一覧：

人名：サム、年齢：18歳

人物名：クシ、年齢：20歳

説明：

ここでは、PersonとGroupのXNUMXつのクラスが、オブジェクトを使用して相互に関連付けられていることがわかります。 社会福祉と演劇祭のXNUMXつのグループがあります。 これらのグループは、personクラスを使用して作成しました。 グループには人のリストがあります。 出力に示されているように、ドラマフェストグループにはサムとクシのXNUMX人がいます。 その後、groupのインスタンスをnullに設定して、このグループを削除しました。 ただし、グループが削除された後も、関連付けが弱いため、つまり集計のために、人のリストは破棄されません。

Javaでの構成

Java構成 は、関係全体の一部を表す関連付けであり、一部は全体なしでは存在できません。 学校と部屋の関係を例にとってみましょう。 学校のオブジェクトは、いくつかの部屋で構成されています。 学校のオブジェクトが自動的に破棄されるときはいつでも、すべての部屋のオブジェクトが破棄されます。つまり、既存の学校のオブジェクトがなければ、既存の依存オブジェクトの可能性はありません。 したがって、これらは強く関連しており、この関係は構成と呼ばれます。 全体が削除されると、すべての部分が削除されます。 したがって、構成は関係の一部を表します。 

XNUMXつのエンティティ間に構成がある場合は常に、作成されたオブジェクトは他のオブジェクトなしでは存在できません。 したがって、構成では、両方のエンティティが相互に依存しています。

次のコード例を検討してください。

import java.util.*; // activity room class
class ActivityRoom { public String subject; public int id; ActivityRoom(String subject, int id) { this.subject = subject; this.id = id; } } // department class class Department { private String name; //list of activity rooms in a department. private List<ActivityRoom> ar; Department(List<ActivityRoom> ar) { this.ar = ar; } // Getting total number of colleges public List<ActivityRoom> getActivityRoomsInDepartment() { return ar; } } class Demo { public static void main(String[] args) { // Creating the Objects of activity room class. ActivityRoom a1 = new ActivityRoom("Technical", 601); ActivityRoom a2 = new ActivityRoom("Business", 602); ActivityRoom a3 = new ActivityRoom("Economics", 603); // making the list of activity rooms. List<ActivityRoom> act = new ArrayList<ActivityRoom>(); act.add(a1); act.add(a2); act.add(a3); // Creating the Object of department class. Department d = new Department(act); // making the list of activity rooms in department. List<ActivityRoom> arlist = d.getActivityRoomsInDepartment(); for (ActivityRoom a : arlist) { System.out.println(a.subject + " activity room with id " + a.id); } } }

出力：

ID601のテクニカルアクティビティルーム

ID602のビジネスアクティビティルーム

ID603の経済活動室

説明：

ここには、アクティビティルームと部門のXNUMXつのクラスがあります。 さまざまな主題の活動室で構成される部門。 したがって、部門が破壊されると、その部門内のすべてのアクティビティルームが破壊されます。つまり、アクティビティルームは部門なしでは存在できません。 それが作曲である理由です。

Javaのメソッド

Java メソッドは、特定のジョブまたは操作を完了するためにグループ化されたコードのブロックまたはステートメントのコレクションです。 これは、コードの再利用性を実現するために使用され、何度も利用できます。 また、簡単な修正を提供します とコードの可読性。 メソッドは、呼び出しまたは呼び出したときにのみ実行されます。 Javaには、事前定義とユーザー定義のXNUMXつのカテゴリのメソッドがあります。 事前定義されたメソッドは、Javaクラスライブラリですでに定義されているメソッドです。 特定のメソッドがユーザーまたはプログラマーによって作成される場合、それはユーザー定義メソッドと呼ばれます。 ユーザー定義のメソッドは、要件に応じて変更できます。

話し合いましょう：

• Javaの静的メソッド
• Javaの抽象メソッド
• Javaでメソッドをファイナライズする
• JavaのEqualsメソッド

Javaの静的メソッド

宣言にstaticキーワードが含まれるメソッドは、staticメソッドと呼ばれます。 つまり、クラスのインスタンスではなくクラスに属するメソッドは、静的メソッドと呼ばれます。 メソッド名の前にキーワードstaticを使用して、静的メソッドを作成することもできます。 静的メソッドの主な利点は、オブジェクトを作成しなくても静的メソッドを呼び出すことができることです。 静的データメンバーにアクセスし、それらの値を変更することもでき、インスタンスメソッドを作成するためにも使用されます。 main（）メソッドは、静的メソッドの一般的な例です。

例：

public class Demo { public static void main(String[] args) { displaymethod(); } static void displaymethod() { System.out.println("It is an example of static method."); } } 

出力：

これは静的メソッドの例です。

Javaの抽象メソッド

キーワードabstractで宣言されたメソッドは、抽象メソッドと呼ばれます。 抽象メソッドには、実装、本体、またはコードのブロックがありません。 抽象メソッドは常に抽象クラスで宣言する必要があります。または、クラスに抽象メソッドがある場合は、抽象として宣言する必要があると言えます。 クラスに抽象メソッドがある場合は、抽象として宣言する必要がありますが、その逆は当てはまりません。つまり、抽象クラスに抽象メソッドを強制する必要はありません。 また、通常のクラスが抽象クラスを拡張する場合、クラスはすべての抽象親クラスの抽象メソッドを実装する必要があります。そうでない場合は、抽象として宣言する必要があります。

例:

//abstract class area
abstract class Area{ /* These two are abstract methods, the child class * must implement these methods */ public abstract int areaSquare(int s); public abstract int areaRectangle(int l, int b); //Normal method public void display(){
System.out.println("Normal method in abstract class Area"); }
}
//Normal class extends the abstract class
class Demo extends Area{ /* If we don't provide the implementation of these two methods, the * program will throw compilation error. */ public int areaSquare(int s){
return s*s; } public int areaRectangle(int l, int b){
return l*b; } public static void main(String args[]){
Area a = new Demo();
System.out.println("Area of square " + a.areaSquare(9));
System.out.println("Area of rectangle " + a.areaRectangle(3,4));
a.display(); }
}

出力：

正方形の面積81

長方形の面積12

抽象クラス Area の通常のメソッド

Javaの最終メソッド

final と宣言されたメソッドは、final メソッドと呼ばれます。 final メソッドをオーバーライドすることはできません。 これは、子クラスが親クラスの final メソッドを問題なく呼び出すことができることを意味しますが、それをオーバーライドすることはできません。 これは、メソッドを final にする主な目的が、サブクラスによるメソッドの変更を停止することだからです。

例:

class DemoParent{ final void method(){
System.out.println("Parent class final method");
} } class Demo extends DemoParent{ //error
void method(){
System.out.println("final method modified inside child class");
} public static void main(String args[]){ Demo d = new Demo(); d.method(); } }

親クラス（demoParent）の子クラス（demo）内のfinalメソッドを変更しようとすると、上記のコードはエラーをスローします。

メソッドを変更する代わりに、以下に示すように使用できます。

class DemoParent{ final void method(){
System.out.println("Parent class final method");
} } class Demo extends DemoParent{
public static void main(String args[]){ Demo d = new Demo(); d.method(); } }

出力:

親クラスのfinalメソッド

JavaのEqualsメソッド

名前がJavaで示唆しているように、.equals（）は、XNUMXつのオブジェクトが等しいかどうかを比較するために使用されるメソッドです。 javaの.equals（）メソッドは、XNUMXつの文字列の値が類似しているかどうかを確認するために使用されます。 文字ごとにチェックします。 .equals（）メソッドを==演算子と混同しないでください。 String equals（）メソッドは、文字列の内容に基づいてXNUMXつの指定された文字列を比較しますが、アドレスの比較には==演算子が使用されます。 両方の文字列のすべての内容が同じである場合、.equals（）はtrueを返し、そうでない場合はfalseを返します。 すべての文字が一致しない場合は、falseを返します。 

の助けを借りてこれを理解しましょう 例：

public class Demo { public static void main(String[] args) { String s1 = "GreatLearning"; String s2 = "GreatLearning"; String s3 = new String("GreatLearning"); System.out.println(s1 == s2); // true System.out.println(s1 == s3); // false System.out.println(s1.equals(s2)); // true System.out.println(s1.equals(s3)); // true }
}

s1とs3は同じフィールド（コンテンツ）で作成されていますが、メモリ内のXNUMXつの異なるオブジェクトを指しています。 したがって、異なるアドレスで。 したがって、==演算子はfalseを返し、.equals（）メソッドは両方とも同様のコンテンツgreatLearningを含むため、trueを返します。

Javaでのメッセージパッシング

コンピュータの観点からのメッセージパッシングは、プロセス間の通信現象です。 これは、オブジェクト指向プログラミングで使用される一種の通信です。 Javaでのメッセージパッシングは、オブジェクトの送信と同じです。つまり、あるスレッドから別のスレッドへのメッセージです。 スレッドに共有メモリがなく、通信するモニターやその他の共有変数を共有できない場合に使用されます。 メッセージパッシングでは、呼び出し側プログラムがメッセージをプロセスに送信し、そのプロセスに依存して独自の機能またはコードを実行します。 メッセージパッシングは実装が簡単で、パフォーマンスが速く、それを使用して大規模な並列モデルを構築できます。 

同期と非同期のXNUMX種類があります。

• 同期メッセージパッシングは、オブジェクトが同時に実行されるときに発生します。
• 非同期メッセージパッシングの場合、要求側オブジェクトがメッセージを送信すると、受信側オブジェクトがダウンまたはビジーになる可能性があります。

ポリモーフィズム、カプセル化、継承は可能ですか 共に働く？

継承、ポリモーフィズム、およびカプセル化を組み合わせてプログラミング環境を作成すると、この環境は、プログラム指向モデルを実行するはるかに堅牢でスケーラブルなプログラムの開発をサポートします。 クラス階層の適切に設計されたモデルは、開発とテストに時間と労力を費やしたコードを再利用するための基礎となります。 カプセル化により、クラスのパブリック インターフェイスに依存するコードを壊すことなく、時間をかけて実装を移行できます。 ポリモーフィズムにより、読みやすく、クリーンで、実用的なコードを作成できます。

ご存知のように、個々のパーツがオブジェクトに変換されるのは、カプセル化、ポリモーフィズム、および継承の適用によるものです。 たとえば、自動車、携帯電話などです。これは、コンピューター プログラムの場合に当てはまります。 オブジェクト指向の原則により、複雑なプログラムのさまざまな部分がまとめられ、まとまりがあり、堅牢で、保守可能な全体が形成されます。

javaが提供する機能の多くは、カプセル化、ポリモーフィズム、および継承を広範囲に使用する組み込みのクラスライブラリの一部です。 

実際の例を考えてみましょう。 ある観点から見ると、人間は一種の継承ですが、車は私たちが作成するプログラムに似ています。 すべてのドライバーは、さまざまな種類の車両を運転するために継承に依存しています。 さまざまな種類の車両があり、一部には違いがあるため、人々はあらゆる種類の車の機能とやり取りします。 エンジン、ブレーキなどの実装はカプセル化され、最終的にポリモーフィズムになります。 アンチロック ブレーキ システム、従来のブレーキ システム、またはパワー ブレーキ システムと同じ車両で幅広いオプションを利用できます。 ブレーキシステムの多くの形態と同じ車両は、ポリモーフィズムと呼ばれます。 この例は、カプセル化、継承、ポリモーフィズムがどのように組み合わされるかを示しています。   

OOPコンセプトの利点 

いくつかの利点は次のとおりです。

• 再利用性

再利用性とは、「一度書いて、何度も使う」という意味で、何度も建てるのではなく、一部の施設を再利用することで、授業で実現できます。 必要に応じてn回使用できます。

• データの冗長性 

これは、oops の最大の利点の XNUMX つです。 これは、同じデータが XNUMX つの異なる場所に保持されている場合に、データ ストレージで作成される状態です。 複数のクラスで同様の機能を使用したい場合は、それらを継承することにより、同様の機能の共通のクラス定義を記述できます。

• コードのメンテナンス

既存のコードを新しいオブジェクトとして変更または維持するのは簡単で、既存のものとはわずかな違いで作成できます。 これにより、ユーザーは何度もやり直しを行ったり、既存のコードを変更して新しい変更を組み込んだりする必要がなくなります。

データの非表示と抽象化は、限られた露出を除外するために使用されます。つまり、セキュリティを維持しながら、表示に必要なデータのみを提供します。

• 設計上の利点 

設計者は、より優れた設計につながる、より長くより広範な設計フェーズを持つことになります。 プログラムが限界に達した時点で、すべての非 oops を個別にプログラムする方が簡単になります。

• 簡単なトラブルシューティング

カプセル化オブジェクトの使用には自己制約があります。 したがって、開発者が問題に簡単に直面した場合、それは解決できます。 また、コードが重複する可能性はありません。 

• 柔軟性 
• 問題解決

OOPコンセプトのデメリット 

• 労力 – これらのプログラムの作成には多くの労力が費やされます。

• 速度–これらのプログラムは他のプログラムに比べて遅いです。

• サイズ– OOPプログラムは、他のプログラムと比較すると大きくなっています。

オブジェクト指向プログラミングと手続き型プログラミングの違いは？

で無料のコースを受講すると、oops の概念について詳しく学ぶことができます。 おっと C++ の概念.

オブジェクト指向プログラミング言語とオブジェクトベースのプログラミング言語の違いは？

JavaFAQのオブジェクト指向

• SEO を活用したコンテンツと PR 配信。 今日増幅されます。
• Platoblockchain。 Web3メタバースインテリジェンス。 知識の増幅。 こちらからアクセスしてください。
• 情報源： https://www.mygreatlearning.com/blog/oops-concepts-in-java/