Javaオブジェクト指向の考え方の本質（4）

1.パッケージとパッケージリファレンス

（一）パッケージ、輸入

• パッケージ：

1. 役割：クラス名の競合を回避するため。
2. パッケージ名は階層構造にすることができます。クラスのフルネーム：パッケージ名。クラス名。
3. 提案：パッケージ名のすべての文字は小文字にする必要があります。
4. 同じパッケージ内のクラスのクラス名を同じにすることはできません。

• インポート：

1. 同じパッケージ内のクラスに直接アクセスすることはできますが、異なるパッケージ内のクラスに直接アクセスすることはできません。アクセスする方法は2つしかありません
   。1.1。まず、インポートしてクラスを宣言し、クラスを使用します------提案。
   1.2。クラスのフルネームは扱いにくいため、お勧めしません。

2、アクセス制御修飾子

（1）パブリック、プライベート、保護、デフォルト

• public：public、どのクラスにもアクセスできます。
• private：private、このクラスでのみアクセス可能。
• protected：protected、このクラス、派生クラス（サブクラス）、および同じパッケージ内のクラスにアクセスできます。
• デフォルト（それが良いと言う別の言い方）：何も書かれておらず、このクラスと同じパッケージクラスでアクセスできます。
• 説明：
  • クラスのアクセス修飾子は、パブリックまたはデフォルト（記述されていない）のみにすることができます。
  • クラスのメンバーのアクセス修飾子は、上記の4つのタイプのいずれかになります。

コード栗：

package oop.day05;
//同包类：同一个包下的 class 类文件
//演示访问控制修饰符
public class Aoo {
    
    
	public int a;    //任何类
	protected int b; //本类、派生类、同包类
	private int d;   //本类
	int c;           //本类、同包类
	
	
	public void show() {
    
    
		a = 1;
		b = 2;
		c = 3;
		d = 4;
	}
}

class Boo{
    
     //演示private
	public void show() {
    
    
		Aoo o = new Aoo();
		o.a = 1;
		o.b = 2;
		o.c = 3;
		//o.d = 4;
	}
}

同じパッケージクラス（パッケージoop.day05のクラスと同じ）

package oop.day05;
public class Coo {
    
     //演示同包类
	public void show() {
    
    
		Aoo o = new Aoo();
		o.a = 1;
		o.b = 2;
		o.c = 3;
		//o.d = 4;
	}
}

//同包中
class Doo extends Aoo{
    
     //演示protected
	public void show() {
    
    
		a = 1;
		b = 2;
		c = 3;
//		d = 4;
	}
}

さまざまなパッケージクラス

package oop.day06;
import oop.day05.Aoo;//先导包
//跨包继承
public class Doo extends Aoo{
    
    
	public void show() {
    
    
		Aoo aoo = new Aoo();
		aoo.a = 1;
		aoo.show();
	}
}

3、最終的なキーワード変更の役割

• 最終的な意味：最終的で変更不可能。
• 最終的に変更された変数、変更されたメソッド、および変更されたクラスの機能と説明は次のとおりです。

1. 変更された変数：変数は変更できません。

   /*
    * final修饰成员变量，只能在如下两种方式下初始化:
    * 1)声明同时初始化
    * 2)在构造方法中初始化
    * final修饰局部变量，只要在用之前初始化即可
    */
   //演示final修饰变量
   class Eoo{
         
         
   	final int num = 5;
   	final int count;
   	Eoo(){
         
         
   		count = 5;
   	}
   	void show() {
         
         
   		final int Number;
   		//count = 8; //编译错误，final修饰的变量不能被改变
   	}
   }
   

2. 変更方法：この方法は上書きできません。

   //演示final修饰方法
   class Foo{
         
         
   	final void show() {
         
         }
   	void say() {
         
         }
   }
   class Goo extends Foo{
         
         
   	//void show() {} //编译错误，final修饰的方法不能被重写
   	void say() {
         
         }
   }
   

3. 変更されたクラス：クラスは継承できません。

   //演示final修饰类
   final class Hoo{
         
         }
   //class Ioo extends Hoo{} //编译错误，final的类不能被继承
   class Joo{
         
         }
   final class Koo extends Joo{
         
         
   
   }
   

4、静的

（1）静的変数

1. 静的によって変更されました。
2. クラスに属するものはメソッド領域に格納され、コピーは1つだけです。
3. 多くの場合、クラス名ドットを介してアクセスされます。
4. 使用する場合：すべてのオブジェクトで共有されるデータ。
5. 注：宣言と初期化を同時に行います。

（2）静的メソッド

1. 静的によって変更されました。
2. メソッド領域には、クラスに属するもののコピーが1つだけあります。
3. 多くの場合、クラス名ドットを介してアクセスされます。
4. 静的メソッドではこの転送が暗黙的に行われないため、静的メソッドでインスタンスメンバーに直接アクセスすることはできません。
5. 使用する場合：メソッドの操作は、オブジェクトではなく、パラメーターにのみ関連します。

（3）静的ブロック

1. 静的によって変更されました。
2. クラスのロード中に自動的に実行されるクラスに属します。クラスは1回だけロードされ、すべての静的ブロックも1回実行されます。
3. 使用する場合：静的ブロックのロード/初期化は、クラスのロード中に自動的に実行されます（1回実行）。
4. 使用シナリオ：たとえば、プログラムを開くときに、静的リソース（画像、オーディオ、ビデオなど）を初期化する必要があります。後の段階でJDBCナレッジコンテンツがあることを学習した後、プロジェクトとデータベース間の接続では、最初にデータベースインターフェイスドライバーをロードする必要があります...

コードデモ：

//static的演示
public class StaticDemo {
    
    
	public static void main(String[] args) {
    
    
		Loo o1 = new Loo();
		o1.show();
		Loo o2 = new Loo();
		o2.show();
		Loo o3 = new Loo();
		o3.show();
		System.out.println("最后的静态变量:"+Loo.b); //常常通过类名点来访问
		
		System.out.println("------------------------------------------");
		
		Moo m = new Moo();
		System.out.println(Moo.b);//通过类名点来访问
		System.out.println(m.a);
		int s = m.test2();
		System.out.println(s);
		
		System.out.println("------------------------------------------");
		
		Noo o4 = new Noo();
		Noo o5 = new Noo();
		Noo o6 = new Noo();
	}
}

class Loo{
    
     //演示静态变量
	int a;
	static int b;
	Loo(){
    
    
		a++;
		b++;
	}
	void show() {
    
    
		System.out.println("静态变量:"+a+","+b);
	}
}
//静态变量，static修饰 属于类的，存储在方法区中，只有一份



class Moo{
    
     //演示静态方法
	int a=88;
	static int b=56;
	void show() {
    
     //有隐式this
		System.out.println(this.a);
		System.out.println(Moo.b);
	}
	static void test() {
    
     //没有隐式this
		//静态方法没有隐式的this传递
		//没有this就意味着没有对象
		//而实例变量a必须通过对象点来访问
		//所以此处编译错误，因为静态方法中不能直接访问实例成员,得先创建对象再访问。
		
		//System.out.println(a); //编译错误
		System.out.println(b);
	}
	int test2() {
    
    
		return a;
	}
}


class Noo{
    
    
	static {
    
    
		System.out.println("静态块");//静态块只加载一次
	}
	Noo(){
    
    
		System.out.println("构造方法");
	}
}

結果グラフ：

5、静的最終定数

1. 使用する前に、宣言と初期化を同時に行う必要があります。
2. 通常、クラス名ドットを介してアクセスされ、変更することはできません。
3. 提案：定数名のすべての文字は大文字にし、複数の単語は_下線で区切る必要があります。
4. コンパイラは、コンパイル中に定数を特定の数値に直接置き換えるため、非常に効率的です。
5. 使用する場合：データを変更しないでおく必要がある場合は、頻繁に使用してください。

//static final常量的演示
public class StaticFinalDemo {
    
    
	public static void main(String[] args) {
    
    
		System.out.println(Aoo1.PI); //常量通过类名点来访问
		//Aoo.PI = 3.1415926; //编译错误，常量不能被改变
		
		
		//1)加载Boo.class到方法区中
		//2)静态变量num也存储到方法区中
		//3)到方法区中获取num的值并输出
		System.out.println(Boo.num);
		
		
		//编译器在编译时将常量直接替换为具体的值，效率高
		//相当于System.out.println(5);
		System.out.println(Boo.COUNT);
		
	}
}

class Boo{
    
    
	public static int num = 5; //静态变量
	public static final int COUNT = 5; //常量，常量名所有字母都大写
}

class Aoo1{
    
    
	public static final double PI = 3.14159;
	//public static final int NUM; //编译错误，常量必须声明同时初始化
}

フォローアップの内容をお待ちください。すぐに来てください！書くのは簡単ではありません。3Qに感謝します。

章のリストはここにあります：https：//blog.csdn.net/qq_41254299/article/details/106638651

再印刷のソースを示してください：https：//blog.csdn.net/qq_41254299
この記事は[Superclover_のブログ]からのものです