Java10万語ノート（インデックス付き）

class Person{//capitalize
String name;//access control permission is the default
int age;//access control is the default
//define two properties, will automatically give the default value null and 0
public void tell(){ //no static
// method definition and invocation are added (), divided into two cases with and without reference
System.out.println( name + '\t' + age );
// you can access member variables (properties) directly in the method
}
}

Q：なぜ、この場所でメソッドtell()がstaticで定義されていないのでしょうか？

A: 呼び出し方法が違う、オブジェクトから呼び出されるメソッドは定義に static を加える必要はない、そうでなければ static を加える（例えば、メインクラス public class Test{} で定義され、メインクラスから直接呼び出されるメソッドは static を加える必要がある）。

オブジェクトの定義と使用

class object = new class().

オブジェクト . 属性 = xxxxx ;

対象物 . メンバー関数（）です。

public class Test{
public static void main(String [] args){
Person zhang = new Person(); 
// Declare and instantiate with (), because Java needs to determine what constructor to use
/*
* It can also be declared and instantiated in two steps
* Declare: Person zhang = null ;
*Instantiate: zhang = new Person();
*/
zhang.name = "Zhang San";// call the object's properties outside the class
zhang.age = 20 ;// call the object's properties outside the class
zhang.tell();
// use the method to add (), because Java needs to determine whether there are parameters
}
}

メンバープロパティのパーミッション

オブジェクト指向の特徴のひとつにカプセル化がありますが、カプセル化の特徴のひとつに内部構造が外から見えないということがあります

上のコード例では、String name; と int age; はいずれもクラスの外から呼び出されたオブジェクトのプロパティで、安全ではありません。

メンバーのプロパティやメソッドをprivateでカプセル化した後、それらを呼び出すにはpublic コンストラクタやその他のメソッドにアクセスしたり、変更したりすることができます。

コンストラクタのメソッドだけでは、メンバプロパティはデフォルト値しかなく、変更することはできません。そこで、getter()メソッドやsetter()メソッドを導入して、アクセスや変更を行うようにします。

コンストラクタのメソッド

1. コンストラクタメソッド許可制、戻り値なし、クラス名と一致する名前。

2. コンストラクタ・メソッドを宣言しても、パラメータも関数本体もないコンストラクタ・メソッドは自動生成されない

class Person{
//..... omit
/*
*public Person(){}
*default constructor, no parameters, no function body, if none of the constructors are defined, the compiler automatically completes
* No reference but function body is a normal constructor ~
*/
public Person(Person per){
name = per.name;
age = per.age;
}
// copy construction (deep copy) (deep and shallow copy search for yourself ~)
//not pass the address, but new a heap space one by one copy


/***The following are two overloaded constructor methods***/
Person(String Name){
name = Name;
age = -1;
}

Person(String Name , int Age){
name = Name;
age = Age;
}
//..... omit
}

ディープコピーとシャローコピーの違い

Person liu = new Person(zhang);
//This works only if the copy construct is defined in the Person class
liu.tell();
//The result is: Name: Zhang San, Age: 20
zhang.age = 21;
liu.tell();
// the result is still: Name: Zhang San, age: 20
/********* deep copy ************/

ディープコピー：異なる空間を指す2つのオブジェクトが、互いに影響を及ぼさないようにすること

Person liu = null;
liu = zhang ;//pass by reference
zhang.name = "张豪猪";
liu.tell();
// the result is: name: Zhang porcupine, age: 20
/******** shallow copy of **********/

シャローコピー：2つのオブジェクトが同じ空間を指す、変更の同期化

メンバープロパティのラッピング、オーバーロードされたインスタンスの構築

<ブロッククオート

4つのパーミッション修飾子はすべてカプセル化の表現で、privateは「はい」、publicは「デフォルトで保護されています」の両方です。

権限サイズ private<default<protected<public（プライベート＆デフォルト＆プロテクト＆パブリック

パーミッションごとの可視範囲について説明した図

属性をプライベートとしてラップする

class Person {
	private int age;
	private String name;
4 overloads of the /******* constructor ********/
	public Person() {
		age = 123456;
		name = "unknown";
	}

	public Person(int Age) {
		age = Age;
		name = "unknown";
	}

	public Person(String Name) {
		age = 123456;
		name = Name;
	}

	public Person(int Age, String Name) {
		age = Age;
		name = Name;
	Name; }
        public Person(String Name, int Age){
		age = Age;
		name = Name;
	name = Name; }
/* 5 overloads of constructor methods, including 1 no-parameter constructor, 2 single-parameter constructor, 2 two-parameter constructor all cases */
/* It is recommended to write constructors in order: parameters from more to less or parameters from less to more */
	public void tell() {
		System.out.println("name: " + name + ", age: " + age);

	}
}

public class Test4 {
	public static void main(String[] args) {
		Person per1 = new Person();
		per1.tell();
		Person per2 = new Person(18);
		per2.tell();
		Person per3 = new Person("张猪豪");
		per3.tell();
		Person per4 = new Person(20, "张豪猪");
		per4.tell();
                Person per5 = new Person("窝瓜刘",18);
		per5.tell();
		/*
		 * per4.name = 10 ; 
		 * The error The field Person.name is not visible
		 */
	}
}

privateの後は メソッド プロパティのメンバにアクセスしたり変更したりするために

per4.setName("I'm a tender father");
System.out.println(per4.getName());

結果

なぜカプセル化するのか？

<ブロッククオート

を使用して属性を追加または削除することが必要な場合があります。 ロジック をラップせずに、例えば
legsNumberというプロパティを持つAnimalsクラスを作成し、動物の足は偶数なので、public legsNumberを直接定義すると、特異点の論理エラーが発生する
Balance プロパティと withdraw メソッドを持つ Account クラスを作成し、引き出しには "残高が十分かどうかを判断する" というロジックを持たせる必要があります。

public class Account{
private int balence;

public void withdraw(int qk){
if(balence>=qk){
balence -= qk;
}
else{
System.out.println("balance insufficient");
}
}
}

参照渡し（シャローコピー）とガベージ解析

Javaでは、管理を容易にするために 自動ガベージコレクション機構 - CG (手動CGと自動CG) それでも、プログラミング開発においては、性能に影響を与えないようにガベージ生成を避けるように心がけることが重要です

CG：ガベージコレクション

Person Zhang = new Person("张三",20);
Person Liu = new Person("刘芒",18);
Liu = Zhang ;
/***** shallow-copy, reference-passing ****/

Liuのオリジナルのメモリ空間ヒープには、スタックメモリスタックへの参照がないため、ガベージスペースとなり使用できなくなり、すべてのガベージスペースは、時々CGによって解放されるのを待つことになります

匿名オブジェクト（宣言されていない、直接インスタンス化されたもの）。

<スパン 1. 一度しか使用できず、使い切るとゴミスペースとなり再利用されるのを待っている

2. 最初にコンストラクタが必要（書かないとデフォルトで使える、ただ意味はない）

3. コンストラクタ・メソッドを使用すると、ヒープ・メモリで開きながらオブジェクトをインスタンス化できるので、指し示すスタック・メモリがなくてもオブジェクトを一度使用でき、そのために ポインティングオブジェクトを持たないオブジェクト と呼ばれます。 匿名オブジェクト

4. 匿名オブジェクトは 直接出力する または を返り値として使用します。

new Person().tell();
new Person("张豪猪",20).tell();
new Person(18,"窝刘瓜").tell();

new Person().setName("melon");//will not report an error, but there is no point
System.out.println(new Person().getAge());

結果

また、匿名オブジェクトは、以下のように作成し、その後もずっと使用することができます。

https://blog.csdn.net/m0_56079407/article/details/119322594

参照型を受け入れるためのコンストラクタ(構成子)の使用

クラスも参照データ型なので、以下のメソッドを使ってクラスを正式なパラメータとして受け取ることができます（PersonクラスとStudentクラスの完全な定義は、コードの前半に示されています）。

class Person {
	private int age;
	private String name;

	//constructor
        public Person(){}//Must be written out separately, otherwise it will report an error when there is no reference
	public Person(int Age) {
		age = Age;
	}

	public Person(String Name) {
		name = Name;
	}

	public Person(int Age, String Name) {
		age = Age;
		name = Name;
	Name; }

	public Person(String Name, int Age) {
		age = Age;
		name = Name;
	}

/***** use the constructor method to accept reference types ******/
	public Person(Student std) {
		/**
		 * age = std.age; name = std.name; This is the wrong way to write
                 * because the properties of the Student class are private
		 * The get method must be defined to call
		 */
		name = std.getName();
		age = std.getAge();
	}

/**** Define get and set methods to access the properties that modify the private ****/
	public String getName() {
		return name;
	}

	public void setName(String Name) {
		name = Name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int Age) {
		age = Age;
	}

/**** define get and set methods to access modify the private properties ****/

// definition of other methods
	public void tell() {
		System.out.println("Name: " + name + "\t age: " + age);
	}

}



class Student {
	private String name;
	private int age;
	private int student_num;
	private int class_num;

	public Student() {
		name = "John Doe";
		age = -1;
		student_num = -1;
		class_num = -1;
	}

	public Student(String Name, int Age, int Snum, int Cnum) {
		name = Name;
		age = Age;
		student_num = Snum;
		class_num = Cnum;
	}

	// The remaining constructor overloads are omitted

// Use constructor methods to accept reference types
	public Student(Person per) {
		name = per.getName();
		age = per.getAge();
	}

/**** Define get and set methods to access the properties that modify the private ****/
	public String getName() {
		return name;
	}

	public void setName(String Name) {
		name = Name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int Age) {
		age = Age;
	}

	public int getSnum() {
		return student_num;
	}

	public void setSnum(int Snum) {
		student_num = Snum;
	}

	public int getCnum() {
		return class_num;
	}

	public void setCnum(int Cnum) {
		class_num = Cnum;
	}

/**** Define get and set methods to access the properties that modify the private ****/
	public void tell() {
		System.out.println("Name: " + name + "\t age: " + age+ "\t student_num:" + student_num + "\t class:" + class_num);
	}
}


public class Test6 {
public static void main(String[] args) {
	Person zhangsan = new Person("Zhang San",18);
	Student liumang = new Student("LiuMang",20,1438438,3);
	
	Student ZhangSan = new Student(zhangsan);
	Person LiuMang = new Person (liumang);
//formal reference is a reference data type, the specific implementation in the class definition
// assign some of the properties of the formal parameters to the object
	zhangsan.tell();
	liumang.tell();
	ZhangSan.tell();
	LiuMang.tell();
}
}

結果

Student クラスにメソッドを追加 (expel student fire)

public void fire(Student std){
	System.out.print("This student has been expelled:\t");
	std.tell();
	std.name = "has been expelled";
	std.age = -2;
	std.class_num = -2;
	std.student_num = -2;
}//New object can be used multiple times and become garbage after jumping out of this structure
 //because the form reference is called, it also creates a stack space in the
//a space on the stack to point to anonymous objects, which are still anonymous in nature and disappear when they are used up

呼び出しは任意であること オブジェクトをキャリアとする を fire() メソッドで実行します。

liumang.fire(new Student("王老五",18,1582141,3));
// call fire with any object, new an object in fire, fire method only operate on the new out object
liumang.tell();//fire's operations on properties do not affect liumang

この操作 は、キャリアオブジェクトに影響を与えません。

JavaBeanは、Java言語で記述された再利用可能なコンポーネントである

JavaBeanは、以下の条件を満たすJavaクラスです。

<ブロッククオート

>クラスはpublic public class xxx{}です。

>パラメータを持たないパブリックなコンストラクタがあります。

は、対応する get および set メソッドを持つプロパティを持っています。

このキーワード

呼び出し方法です。

this.property this.method

this() this (正式なパラメータのリスト)

クラス定義モジュールで 一般的なメソッドまたはコンストラクタ で、クラスの属性がリネームされている場合、誰が属性で誰が正式なパラメータかを区別するために、これを使用する必要があります

public void setName(String Name){
name = Name;
}/// Formal parameters and property names are not duplicated, no need to add this.

public void setName(String name){
this.name = name;
}//Name conflict, this.name means class attribute

this.property this.methodを使用することで示すことができる。

現在のオブジェクトまたは現在作成中のオブジェクトを呼び出します。

これはコンストラクタを呼び出します。

this (正式なパラメータのリスト); コンストラクタの最初の行に記述する必要があり、コンストラクタごとに最大で 1 つの this() を記述します。

n個のコンストラクタは最大n-1個のthis（形式パラメータ）を定義でき、"exit"を残す必要があります。

コンストラクタはthis（形式パラメータ）で自分自身を呼び出すことはできず、"前のレベル"のみです。

上記のPersonクラスの定義は長くて臭いし、異なるコンストラクタのほとんどは重複しているので、単純化すると次のようになります。

public void birth(){
System.out.println("A Person has been created")
}

public Person(){
this.birth();//this.method is applied, this.can be omitted
}

public Person(String name){
this();
this.name = name;
}

public Person(String name , int age){
this(name);//this() will automatically determine which constructor corresponds to the formal parameters, and then jump to call
this.age = age;
}

この時点で、Person クラスを作成します。

Person per1 = new Person("Zhang San",18);

この時点のコンストラクタ呼び出しの順序は、this (name) が Person (String name) コンストラクタにジャンプし、最初の行で this () に遭遇し、this () がない Person () コンストラクタにジャンプし、そこから順に呼び出しが戻ってくるというものです。

packageキーワードとimportキーワード

パッケージ パッケージ。プロジェクトの中で、特定のユニークな機能を果たすために多くのクラスを集めて管理するパッケージで、機能ごとに異なるパッケージで書かれている。コンパイラの最初の行でパッケージZJH.HJZ.bankTestを宣言してください。

パッケージ名をキーワードで指定すると、実行時にエラーが発生します。

import: 指定されたパッケージの下にあるクラスまたはインターフェイスをインポートするために import を使用します。

継承する。

4つの視認性テスト

まず、親クラスの4つのプロパティとメソッドを異なる権限で定義することから始めましょう。

public class Super {//public class
	private int Pri;
	int Def;
	protected int Pro;
	public int Pub;
//properties of the four permissions	
	public Super(){}
	public Super(int Pri, int Def , int Pro, int Pub){
		this.Pri=Pri;
		this.Def=Def;
		this.Pro=Pro;
		this.Pub=Pub;
	}
//construction	
	private void PriTest(){
		System.out.println("private");
	}
	void DefTest(){
		System.out.println("defualt");
	}
	protected void ProTest(){
		System.out.println("protected");
	}
	public void PubTest(){
		System.out.println("public");
	}
// four methods of permission
}

次に、ちょっとだけ同じパッケージの下にメインのクラスTestを作ります。

同じパッケージの下で、親クラスはprivateを除く3つのサブクラスすべてから見え、親クラスの種のプライベートプロパティまたはメソッドにアクセスすることができます。 子クラスがアクセスできるメソッドにprivateを入れることができる

public void DefTest(){
  System.out.println("defualt");
  PriTest();
	}

継承とパーミッションの可視性はどのように理解すればよいですか？

視点1．

アングル2

アングル3

継承と可視化のまとめ

まとめ

パーミッションのサイズ：public>protected>default>private

レベルアウトするごとに、見える範囲が1つ狭くなります。

同じパッケージから任意のクラス（サブクラス、ノーマルクラス）を作成する。 : private は表示されなくなりました。

パッケージをまたがるサブクラスの作成 : デフォルトも表示されなくなりました

パッケージ間で共通のクラス（サブクラスではない）を作成すること。 protected も表示されなくなりました。

実際には、開発現場ではpublicとprivateしか使われないのが一般的です

パブリッククラスとデフォルトクラスの違いは何ですか？

パブリッククラスは、同じプロジェクト内のすべてのパッケージで使用することができます。

デフォルトのクラスは、このパッケージでのみ使用可能

可視は不可視に、不可視は可視になることができ、その鍵は 最後の1つはどのように継承されたのか が決定します。

相続に関するいくつかの規定

1. Javaでは多重継承ではなく、多層継承のみが認められている：親クラスは複数の子に継承できるが、子クラスは1つの親クラスからしか継承できない

2. 2.継承のレベルが多すぎないこと、一般に読みにくさを避けるために3レベル以上は推奨されません。

*java.lang.Objectクラスを明示的に継承しないクラスはすべてjava.lang.Objectクラスを継承し、"孫"は依然として親クラスの全機能を持つため、すべてのクラスはObjectクラスの全機能を持ちます。

4. いったん継承されると、すべてのプロパティとメソッドが継承されます。ただし、パーミッションのカプセル化された性質により 可視でないため直接呼び出せないが、間接的に呼び出せる（不可視メソッドを可視メソッドに書き換える）内容もある

継承：サブクラスの構成

サブクラスのオブジェクトは、親オブジェクトをインスタンス化する前にインスタンス化する必要があり、これは実際には暗黙の super() 形式を持つサブクラスのコンストラクタと等価です。

super (正式なパラメータのリスト) は、サブクラスのコンストラクタの最初の行にある必要があります。

親クラスのコンストラクタです。

public Super(){
System.out.println("Called parent class with no reference constructor");
}

サブクラスのコンストラクタ：参照なしのsuper()は省略可

public class Sub extends Super {
	public Sub(){//subclass constructor without parameters
		super();//Explicitly point out the call to the parent class constructs, do not write the default to find the parent class uninvolved constructs
		System.out.println("Called the subclass uninvolved constructor");
	}
}

テスト中です。

public class Test {
	public static void main(String[] args) {
		Sub A = new Sub();
	}
}

結果

サブクラスがパラメータ付きのコンストラクタを定義する場合、スーパー（正式なパラメータのリスト）は親クラスのコンストラクタと一致する必要があります。

this()とsuper()の具体的な使用方法

this() と super() はどちらもコンストラクタで、どちらも最初の行が必要ですが、同時に現れるのは these() と super() のいずれか一方のみで、一般に親コンストラクタには this（正式パラメータ）、サブクラスには super（正式パラメータ）が使用されます。

super (形式パラメータリスト) コンストラクタ

super が親クラスのコンストラクタを探すことを除けば、効果はこれと同じです。

class Person{
	private String name;
	private int age;
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
}
class Student extends Person{
	private int id;
	
	public Student(String name, int age, int id) {
		//complete set of formal parameters
		super(name, age);//super() construct first
		this.id = id;
	}
}

親のプロパティに関係なく、子のコンストラクタでは public プロパティであっても super (正式なパラメータのリスト) を使用しなければならず、継承したプロパティを子のコンストラクタで this. や super. で初期化することはできません。

<ブロッククオート

によってインスタンス化されたサブクラスオブジェクト

メソッドオーバーライド（書き換え）：名前同じ名前、同じパラメータ、ほぼ同じ戻り値

Java10万語ノート（インデックス付き）

Javaクラスとオブジェクト学習の学習ルート

名詞の別名

パーミッションモディファイア（アクセス制御の許可属性）

属性のデフォルト値

クラスとオブジェクトの定義

オブジェクトの定義と使用

メンバープロパティのパーミッション

コンストラクタのメソッド

ディープコピーとシャローコピーの違い

メンバープロパティのラッピング、オーバーロードされたインスタンスの構築

なぜカプセル化するのか？

参照渡し（シャローコピー）とガベージ解析

匿名オブジェクト（宣言されていない、直接インスタンス化されたもの）。

参照型を受け入れるためのコンストラクタ(構成子)の使用

JavaBeanは、Java言語で記述された再利用可能なコンポーネントである

このキーワード

これはコンストラクタを呼び出します。

packageキーワードとimportキーワード

継承する。

4つの視認性テスト

継承とパーミッションの可視性はどのように理解すればよいですか？

継承と可視化のまとめ

パブリッククラスとデフォルトクラスの違いは何ですか？

相続に関するいくつかの規定

継承：サブクラスの構成

this()とsuper()の具体的な使用方法

super (形式パラメータリスト) コンストラクタ

によってインスタンス化されたサブクラスオブジェクト

メソッドオーバーライド（書き換え）：名前 同じ名前、同じパラメータ、ほぼ同じ戻り値

関連

最新

おすすめ

メソッドオーバーライド（書き換え）：名前同じ名前、同じパラメータ、ほぼ同じ戻り値