Java開発訓練

#01. Java開発環境構築
##0101. Javaインストール
###010101. jdk1.8.0_241 ダウンロードアドレス
https://www.oracle.com/cn/java/technologies/javase-jdk8-downloads.html
　
###010102. 手順書によってインストールして下さい。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/7eb025cf-ecd0-f260-749a-782c7d159e0a.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/5a13191b-df42-68e1-7321-eae1abe28952.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/52596ec8-84ba-5a0b-f75e-0e21595d6c93.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/5a555ede-36f2-89ac-9be5-b9d3a93da491.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/05543e87-9b04-66d4-2193-4d84bdee9703.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/4583bde8-8486-615b-e5e9-573c06390083.png)

###010103. JAVA_HOME設定
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/bf17cb8f-4f73-286b-12ca-6867dc3a6610.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/8435f112-63fd-b500-2ff5-92c64341564c.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/d6467b02-56be-26b6-8c5d-8b08997b9d78.png)

##0102. IDEインストール
###010201. IntelliJ IDEA2019.3 ダウンロードアドレス
https://www.jetbrains.com/idea/download/download-thanks.html?platform=windows&code=IIC

###010202. 手順書によってインストールして下さい。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/cb572b54-a56d-b0c4-73f8-331485c0ee1f.png)のダブルクリック
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/4d78a8b5-4e53-738f-c7fc-92cc7f7e78e9.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/45ed279d-c4d5-7171-9177-04609a39b6c5.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/8c921056-8d37-7072-b611-3cd37d22bd9f.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/1077eee4-c8de-0c2a-deec-1c08e0328f97.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/9184f11a-4f65-f574-a8ae-caa0e84ddc7c.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/72df57fb-8866-fa97-3ff1-a7ad34e38857.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/77193807-422a-53d1-cc30-a4a4565242c2.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/6638f92e-2fb0-b87c-8c89-9953e59fa3c9.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/84b73d52-856e-5f7f-f2f3-5e894efcf60d.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/61d947c2-ede0-8716-f71b-5c269df03d5d.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/a9022696-9cd3-22b2-0cd7-9a013c19c5b7.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/5d297782-9b1d-1dc8-d031-e8751f9a857f.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/b4350705-ea3c-7add-f714-236a36e13619.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/dca8adb5-f263-339c-ff4d-1ec18c987ad6.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/88f209e3-2035-9928-6672-32f112a8c75a.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/785f501c-af0b-18e7-8d6f-13c0aa9e9a11.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/25d069a4-60c9-82f1-084f-f213dcfb5abd.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/18a6ab5f-afae-260d-9a45-0815786190db.png)

###010203.その他

- Eclipsen日本語化
(https://mergedoc.osdn.jp/)
- VSCODE(https://code.visualstudio.com/docs/?dv=win64user)

#02. Java基本
##0201.Java-基本構文
■Javaプログラムを考えるとき、以下の要素があります。

- オブジェクト
- クラス
- メソッド
- インスタンス変数

■最初のJavaプログラム

```ruby:java
public class Test {
    /**
     * First program
     * @param args
     */
    public static void main(String []args){
        System.out.println("Hello World!");
    }
}
```
```ruby:cmd
C:\Users\luyu1\IdeaProjects\Learn20200314\src>javac Test.java
C:\Users\luyu1\IdeaProjects\Learn20200314\src>java Test
```
■基本的な構文
Javaプログラムについては、次の点に留意することが非常に重要です。

- 大文字と小文字の区別
- クラス名(大文字から)
- メソッド名（小文字から）
- クラス名＝保存のファイル名
- 実行入口（public static void main（String args []））

■Java識別子
Javaでは、識別子について覚えておくべきポイントがいくつかあります。

- すべての識別子は、文字（A〜Zまたはa〜z）、通貨文字（$）、またはアンダースコア（_）で始まる必要があります。

- 最初の文字の後に、識別子は任意の文字の組み合わせを持つことができます。

- キーワードを識別子として使用することはできません。

- 最も重要なことは、識別子では大文字と小文字が区別されることです。

- 有効な識別子の例：年齢、$ salary、_value、__ 1_value。

- 不正な識別子の例：123abc、-salary。

```ruby:java
```
■Java修飾子
修飾子には2つのカテゴリがあります。

- アクセス可能の修飾子 - default, public , protected, private

- アクセス不可の修飾子 − final, abstract, strictfp

```ruby:java
```
■Java変数
以下は、Javaの変数の種類です

- ローカル変数
- クラス変数（静的変数）
- インスタンス変数（非静的変数）

```ruby:java
```
■Java配列
配列は、同じタイプの複数の変数を格納するオブジェクトです。

■Java列挙

```ruby:java
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);
   }
}
```
■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コンパイラによって無視されます。

```ruby: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");
   }
}
```

■空白行を使用する
おそらくコメント付きの空白のみを含む行は空白行と呼ばれ、Javaはそれを完全に無視します。

■継承
Javaでは、クラスはクラスから派生できます。基本的に、新しいクラスを作成する必要があり、ここに必要なコードの一部が既に含まれている場合、既存のコードから新しいクラスを派生させることができます。
このシナリオでは、既存のクラスはスーパークラスと呼ばれ、派生クラスはサブクラスと呼ばれます。

■インターフェース
Java言語では、インターフェイスは、オブジェクト間の相互通信方法に関する契約として定義できます。インターフェイスは、継承の概念に関して重要な役割を果たします。

インターフェイスはメソッドを定義し、派生クラス（サブクラス）が使用する必要があります。しかし、メソッドの実装は完全にサブクラス次第です。

##0202.Java-オブジェクトとクラス
Javaはオブジェクト指向言語です。オブジェクト指向機能を備えた言語として、Javaは以下の基本概念をサポートしています-

- 多型
- 継承
- カプセル化
- 抽象化
- クラス
- オブジェクト
- インスタンス
- 方法
- メッセージパッシング

この章では、概念-クラスとオブジェクトについて説明します。

Object-オブジェクトには状態と動作があります。例：犬には、色、名前、品種、行動などの状態があり、尾を振ったり、,えたり、食べたりします。オブジェクトはクラスのインスタンスです。

クラス -クラスは、そのタイプのオブジェクトがサポートする動作/状態を記述するテンプレート/設計図として定義できます。

■Javaのオブジェクト
オブジェクトとは何かを詳しく見てみましょう。現実の世界を考えると、私たちの周りの多くのオブジェクト、車、犬、人間などを見つけることができます。これらのオブジェクトはすべて状態と動作を持っています。

犬を考えると、その状態は-名前、品種、色、そして行動は-barえる、尾を振る、走るです。

ソフトウェアオブジェクトを実際のオブジェクトと比較すると、非常によく似た特性があります。

ソフトウェアオブジェクトには、状態と動作もあります。ソフトウェアオブジェクトの状態はフィールドに格納され、動作はメソッドを介して表示されます。

そのため、ソフトウェア開発では、メソッドはオブジェクトの内部状態で動作し、オブジェクト間通信はメソッドを介して行われます。

■Javaのクラス
クラスは、個々のオブジェクトが作成されるものです。

以下はクラスのサンプルです。

```ruby:java
public class Dog {
   String breed;
   int age;
   String color;

   void barking() {
   }

   void hungry() {
   }

   void sleeping() {
   }
}
```
クラスには、次の変数タイプのいずれかを含めることができます。

ローカル変数 -メソッド、コンストラクタ、またはブロック内で定義された変数はローカル変数と呼ばれます。変数はメソッド内で宣言および初期化され、メソッドが完了すると変数は破棄されます。

インスタンス変数 -インスタンス変数は、クラス内のメソッドですが、メソッドの外部の変数です。これらの変数は、クラスがインスタンス化されるときに初期化されます。インスタンス変数は、その特定のクラスのメソッド、コンストラクター、またはブロック内からアクセスできます。

クラス変数 -クラス変数は、静的キーワードを使用して、メソッド内ではなくクラス内で宣言された変数です。

クラスには、さまざまな種類のメソッドの値にアクセスするための任意の数のメソッドを含めることができます。上記の例では、barking（）、hungry（）、sleeping（）がメソッドです。

以下は、Java言語のクラスを調べるときに議論する必要がある重要なトピックの一部です。

■コンストラクター
クラスについて議論するとき、最も重要なサブトピックの1つはコンストラクタです。すべてのクラスにはコンストラクターがあります。クラスのコンストラクタを明示的に記述しない場合、Javaコンパイラはそのクラスのデフォルトコンストラクタを構築します。

新しいオブジェクトが作成されるたびに、少なくとも1つのコンストラクターが呼び出されます。コンストラクターの主なルールは、コンストラクターがクラスと同じ名前を持つ必要があるということです。クラスには複数のコンストラクターを含めることができます。

以下は、コンストラクタの例です

```ruby:java
public class Dog {
   String breed;
   int age;
   String color;
   
   public Dog(){
   }
   public Dog(String breed){
     this.breed = breed;
   }
   void barking() {
   }

   void hungry() {

   }

   void sleeping() {
   }
}
```

■オブジェクトを作成する
クラスはオブジェクトの設計図を提供します。基本的に、オブジェクトはクラスから作成されます。Javaでは、newキーワードを使用して新しいオブジェクトを作成します。
クラスからオブジェクトを作成する場合、3つのステップがあります

- 宣言 -オブジェクト型の変数名を持つ変数宣言。
- インスタンス化 -「new」キーワードを使用してオブジェクトを作成します。
- 初期化 -「new」キーワードの後に​​、コンストラクターの呼び出しが続きます。この呼び出しは、新しいオブジェクトを初期化します。

```ruby:java
public class Dog {
   String breed;
   int age;
   String color;
   
   public Dog(){
   }
   public Dog(String breed){
     this.breed = breed;
   }
   void barking() {
   }

   void hungry() {

   }

   void sleeping() {
   }
   public static void main(String []args) {
      Dog dog1 = new Dog("afador");
   }
}
```

■インスタンス変数とメソッドへのアクセス
インスタンス変数とメソッドは、作成されたオブジェクトを介してアクセスされます。インスタンス変数にアクセスするには、次が完全修飾パスです

```ruby:java
public class Dog {
   private String breed;
   public static int age;
   private String color;
   
   public Dog(){
   }
   public Dog(String breed){
     this.breed = breed;
   }
   private void barking() {
     System.out.println("I am barking!");
   }

   protected void hungry() {
     System.out.println("I am hungry!");
   }

   public void sleeping() {
       System.out.println("I am sleeping!");
   }
   public static void main(String []args) {
      Dog dog1 = new Dog();
      
      String s1 = dog1.breed;//ok?
      int s2 = dog1.age;//ok?
      dog1.barking();//ok?
      dog1.hungry();//ok?
      dog1.sleeping();//ok?
   }
}
```
■ソースファイル宣言規則
このセクションの最後の部分として、ソースファイルの宣言規則を見てみましょう。これらのルールは、ソースファイルでクラス、インポートステートメント、およびパッケージステートメントを宣言するときに不可欠です。

- ソースファイルごとにpublicクラスは1つだけ存在できます。

- ソースファイルには、複数の非publicクラスを含めることができます。

- publicクラス名は、ソースファイルの名前である必要があり、最後に.javaが追加されます。たとえば、クラス名はpublic class Employee {}であり、ソースファイルはEmployee.javaである必要があります。

- クラスがパッケージ内で定義されている場合、パッケージはソースファイルの最初の行である必要があります。

- インポート文が存在する場合は、パッケージ文とクラス宣言の間に記述する必要があります。パッケージがない場合、インポートステートメントはソースファイルの最初の行である必要があります。

- インポートおよびパッケージは、ソースファイルに存在するすべてのクラスを意味します。ソースファイル内の異なるクラスに異なるインポートおよび/またはパッケージを宣言することはできません。

クラスには複数のアクセスレベルがあり、さまざまなタイプのクラスがあります。抽象クラス、最終クラスなど。これらについては、アクセス修飾子の章で説明します。

上記のタイプのクラスとは別に、Javaには内部クラスおよび匿名クラスと呼ばれる特別なクラスもあります。
■Javaパッケージ
簡単に言えば、これはクラスとインターフェースを分類する方法です。Javaでアプリケーションを開発する場合、数百のクラスとインターフェースが作成されます。したがって、これらのクラスを分類することは必須であり、生活をずっと楽にします。

```ruby:java
package jp.co.learning;
```
■インポートステートメント
Javaでは、パッケージとクラス名を含む完全修飾名が指定されている場合、コンパイラはソースコードまたはクラスを簡単に見つけることができます。importステートメントは、コンパイラが特定のクラスを見つけるための適切な場所を指定する方法です。

たとえば、次の行はコンパイラにディレクトリjava_installation / java / ioで利用可能なすべてのクラスをロードするように要求します

```ruby:java
import java.io.*;
```

■実例サンプル１
実例サンプル１では、2つのクラスを作成します。それらはEmployeeとEmployeeTestです。

最初にメモ帳を開き、次のコードを追加します。これはEmployeeクラスであり、クラスはパブリッククラスであることを忘れないでください。次に、このソースファイルをEmployee.javaという名前で保存します。

Employeeクラスには、名前、年齢、指定、給与の4つのインスタンス変数があります。このクラスには、パラメーターを受け取る明示的に定義されたコンストラクターが1つあります。

```ruby:java
package jp.co.learning;
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ファイルに次のコードを保存します。

```ruby:java
package jp.co.learning;
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();
   }
}
```

##0203.Java-コンストラクター
Javaでは、2種類のコンストラクターを使用できます。
- パラメータなしコンストラクタ
- パラメータ化されたコンストラクタ

■パラメータなしコンストラクタ

```ruby:java
Public class MyClass {
   Int num;
   MyClass() {
      num = 100;
   }
}
```
テスト

```ruby:java
public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.num + " " + t2.num);
   }
}
```
■パラメータ化されたコンストラクタ

```ruby:java
public class MyClass {
   int x;
   
   // Following is the constructor
   MyClass(int i ) {
      x = i;
   }
}
```
テスト

```ruby:java
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);
   }
}
```

##0204.Java-基本データ型
Javaには2つのデータ型があります。

- 原始的なデータ型
- 参照/オブジェクトのデータ型

■基本的なデータ型
byte

- バイトデータ型は、8ビットの符号付き2の補数整数です
- 最小値は-128（-2 ^ 7）
- 最大値は127（含む）（2 ^ 7 -1）
- デフォルト値は0
- バイトは整数の4倍小さいため、主に整数の代わりに、バイト配列を使用して大きな配列のスペースを節約します。
- 例：バイトa = 100、バイトb = -50

short

- 短いデータ型は、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

float

- 浮動小数点データ型は単精度の32ビットIEEE 754浮動小数点です
- Floatは、主に浮動小数点数の大きな配列でメモリを節約するために使用されます
- デフォルト値は0.0f
- 浮動小数点データ型は、通貨などの正確な値には使用されません
- 例：float f1 = 234.5f

double

- doubleデータ型は、倍精度64ビットIEEE 754浮動小数点です
- 通常、このデータ型は10進数値のデフォルトのデータ型として使用され、通常はデフォルトの選択です
- doubleデータ型は、通貨などの正確な値には使用しないでください
- デフォルト値は0.0d
- 例：double d1 = 123.4

boolean

- booleanデータ型は1ビットの情報を表します
- 可能な値は2つのみです：trueおよびfalse
- このデータ型は、true / false条件を追跡する単純なフラグに使用されます
- デフォルト値はfalseです
- 例：boolean one = true

char

- charデータ型は単一の16ビットUnicode文字です
- 最小値は '\ u0000'（または0）です
- 最大値は '\ uffff'（または65,535を含む）です
- 文字データ型は、任意の文字を格納するために使用されます
- 例：char letterA = 'A'

■参照/オブジェクトのデータ型
##0205.Java-変数タイプ
すべての変数は、使用する前に宣言する必要があります。
基本的な形式:
data type variable [ = value][, variable [ = value] ...] ;
例:

```ruby: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'
```
3種類の変数があります。

- ローカル変数
- インスタンス変数
- クラス/静的変数

■ローカル変数

- ローカル変数は、メソッド、コンストラクター、またはブロックで宣言されます。

- ローカル変数は、メソッド、コンストラクター、またはブロックに入ると作成され、メソッド、コンストラクター、またはブロックを出ると変数は破棄されます。

- ローカル変数にはアクセス修飾子を使用できません。

- ローカル変数は、宣言されたメソッド、コンストラクター、またはブロック内でのみ表示されます。

- ローカル変数は、内部的にスタックレベルで実装されます。

- ローカル変数にはデフォルト値がないため、最初に使用する前にローカル変数を宣言し、初期値を割り当てる必要があります。

```ruby:java
public Class Test{
  //コンストラクター
  public Test(){
    String str = "test1";
    System.out.println(str);
  }
  //メソッド
  private void test1(){
    String str = "test";
    System.out.println(str);
    
    int test;
    if(test==0){
       int t1 = 1;
       test = t1;
    }
    System.out.println(test);
    System.out.println(t1);
  }

  public static void main(String[] args){
    Test test = new Test();
    test.test1();
  }
}
```
■インスタンス変数
インスタンス変数はクラス内で宣言されますが、メソッド、コンストラクター、または任意のブロックの外部です。

ヒープ内のオブジェクトにスペースが割り当てられると、各インスタンス変数値のスロットが作成されます。

インスタンス変数は、キーワード「new」を使用してオブジェクトが作成されると作成され、オブジェクトが破棄されると破棄されます。

インスタンス変数は、複数のメソッド、コンストラクター、ブロック、またはクラス全体に存在する必要があるオブジェクトの状態の重要な部分によって参照される必要がある値を保持します。

インスタンス変数は、使用前または使用後にクラスレベルで宣言できます。

インスタンス変数にアクセス修飾子を指定できます。

インスタンス変数は、クラス内のすべてのメソッド、コンストラクター、およびブロックに対して表示されます。通常、これらの変数をプライベート（アクセスレベル）にすることをお勧めします。ただし、アクセス修飾子を使用して、これらの変数にサブクラスの可視性を与えることができます。

インスタンス変数にはデフォルト値があります。数値の場合、デフォルト値は0、ブール値の場合はfalse、オブジェクト参照の場合はnullです。値は、宣言中またはコンストラクター内で割り当てることができます。

インスタンス変数は、クラス内の変数名を呼び出すことで直接アクセスできます。ただし、静的メソッド内（インスタンス変数にアクセシビリティが与えられている場合）では、完全修飾名を使用して呼び出す必要があります。ObjectReference.VariableName。

例：

```ruby:java
import java.io.*;
public class Employee {

   // このインスタンス変数は、すべての子クラスに表示されます。
   public String name;

   // salary変数は、Employeeクラスのみで表示されます。
   private double salary;

   // name変数はコンストラクターで割り当てられます。
   public Employee (String empName) {
      name = empName;
   }

   //salary 変数には値が割り当てられます。
   public void setSalary(double empSal) {
      salary = empSal;
   }

   // このメソッドは、従業員の詳細を出力します。
   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();
   }
}
```

■クラス/静的変数

- 静的変数とも呼ばれるクラス変数は、クラス内でstaticキーワードを使用して宣言されますが、メソッド、コンストラクター、またはブロックの外部です。

- そこから作成されるオブジェクトの数に関係なく、クラスごとに各クラス変数のコピーは1つしかありません。

- 静的変数は、定数として宣言される以外にはめったに使用されません。定数は、public / private、final、およびstaticとして宣言される変数です。定数変数は初期値から決して変化しません。

- 静的変数は静的メモリに保存されます。finalと宣言され、パブリックまたはプライベート定数として使用される静的変数以外を使用することはまれです。

- 静的変数は、プログラムの起動時に作成され、プログラムの停止時に破棄されます。

- 可視性はインスタンス変数に似ています。ただし、ほとんどの静的変数は、クラスのユーザーが使用できる必要があるため、パブリックと宣言されています。

- デフォルト値はインスタンス変数と同じです。数値の場合、デフォルト値は0です。ブール値の場合、falseです。オブジェクト参照の場合、nullです。値は、宣言中またはコンストラクター内で割り当てることができます。さらに、特別な静的初期化ブロックで値を割り当てることができます。

- クラス名ClassName.VariableNameを呼び出して静的変数にアクセスできます。

- クラス変数をpublic static finalとして宣言する場合、変数名（定数）はすべて大文字です。静的変数がパブリックおよびファイナルでない場合、命名構文はインスタンス変数およびローカル変数と同じです

```ruby:java
import java.io.*;
public class Employee {

   // salary変数はプライベートな静的変数です
   private static double salary;

   // DEPARTMENTは定数です
   public static final String DEPARTMENT = "Development ";

   public static void main(String args[]) {
      salary = 1000;
      System.out.println(DEPARTMENT + "average salary:" + salary);
   }
}
```

##0206.Java-修飾子タイプ
修飾子は、意味を変更するためにこれらの定義に追加するキーワードです。

- アクセス制御修飾子
- 非アクセス修飾子

■アクセス制御修飾子

Javaには、クラス、変数、メソッド、およびコンストラクターのアクセスレベルを設定するための多数のアクセス修飾子が用意されています。4つのアクセスレベルは-

- パッケージに表示されます。デフォルトです。修飾子は必要ありません。
- クラスのみに表示されます（private）。
- 世界に公開（public）。
- パッケージとすべてのサブクラスに表示されます（protected）。

■非アクセス修飾子
Javaは、他の多くの機能を実現するために、多くの非アクセス修飾子を提供します。

- クラスのメソッドと変数を作成するためのstatic修飾子。

- 最後のクラス、メソッド、および変数を実装するfinal修飾子。

- 抽象クラスおよびメソッドを作成するためのabstract修飾子。

- 同期および揮発性のスレッドに使用されているsynchronizedとvolatile修飾子。

##0207.Java-基本演算子
すべてのJava演算子を次のグループに分けることができます。

- 算術演算子
- 関係演算子
- ビット演算子
- 論理演算子
- 割り当て演算子

- その他の演算子

■算術演算子
算術演算子は、代数で使用されるのと同じ方法で数式で使用されます。次の表は、算術演算子を示しています。

|オペレーター	|説明	|例|
|:-----------:|:--------------:|:-------------:|
|+（追加）|演算子の両側に値を追加します。|A + Bは30を与えます|
|-（減算）|左側のオペランドから右側のオペランドを減算します。|A-Bは-10を与える|
|*（乗算）|演算子の両側の値を乗算します。|A * Bは200を与えます|
|/（整除）|左側のオペランドを右側のオペランドで除算します。|B / Aは2を与えます|
|％ （剰余）|左側のオペランドを右側のオペランドで除算し、剰余を返します。|B％Aは0を返します|
|++（増分）|オペランドの値を1増やします。|B ++は21を与えます|
|--（デクリメント）|オペランドの値を1減らします。|B-- 19を与える|

以下の3個javaファイルには「/%」で普通のプロジェクトの中に頻繁的に使用した改ページ計算をサンプルとしてリストする。

```ruby:ファイル：jp.co.learning.Config.java
package jp.co.learning;

/**
* クラス：配置
* 作成者：AAAAAA
* 作者日：2020/03/01
*/
public class Config{
    /*
     *ページ毎に最大レコード数を表示するデフォルト値
     */
    public final static int DEFAULT_EACH_PAGE_CNT = 0;

}

```

```ruby:ファイル：jp.co.learning.Page.java
package jp.co.learning;
/**
* クラス：改ページ
* 作成者：AAAAAA
* 作者日：2020/03/01
**/
public class Page{

　　 /**
     * 表示用のレコード数
     **/
　　 private int records;
    /**
     * レコード数のページ数
     **/
    private int pageCnt;
    /**
     * 最後ページのレコード数
     **/
    private int endPageCnt;
　　 /**
     * 表示用のレコード数
     **/
　　 private int eachPageCnt = Config.DEFAULT_EACH_PAGE_CNT;

　　 /**
     * コンストラクタ
     **/
     public Page(int records){

        this.records = records;

     }
　　 /**
     * 改ページ
     **/
     public void changePage(){

         //レコード数＝０の場合は、直接的に０として戻る
         if(records == 0){
           return;
         }
         //レコード数>０の場合は、改ページ計算処理を行う
         if(records % eachPageCnt == 0){
           endPageCnt = eachPageCnt;
           pageCnt = records / eachPageCnt;
         }else{
           endPageCnt = records % eachPageCnt;
           pageCnt = records / eachPageCnt + 1;
         }
     }
     /**
     * 総ページ数を取得する
     * @return:総ページ数
     **/
     public int getPageCnt(){
         return this.pageCnt;
     }
     /**
     * 最後ページのレコード数を取得する
     * @return:最後ページのレコード数
     **/
     public int getEndPageCnt(){
         return this.endPageCnt;
     }
}
```

```ruby:ファイル：jp.co.learning.Test.java
package jp.co.learning;
/**
* クラス：改ページのテストクラス
* 作成者：AAAAAA
* 作者日：2020/03/01
**/
public class Test{
  /**
   * テスト入り口
   **/
   public static void main(String[] args){
       //仮にDBから抽出したレコード数を設定する
       int records = 100;

       //Pageクラスでpageインスタンスを作って改ページ計算を行う
       Page page = new Page(records);
       page.changePage();

       //計算したページ数と最後ページのレコード数を出力する
       System.out.println("ページ総数："+page.getPageCnt());
       System.out.println("最後ページのレコード数："+page.getEndPageCnt());
   }
}
```
■関係演算子

|オペレーター|	説明	|例|
|:----:|:----:|:----:|
|==（等しい）|2つのオペランドの値が等しいかどうかを確認し、等しい場合は条件が真になります。|	（A == B）は正しくありません。|
|！=（等しくない）|2つのオペランドの値が等しいかどうかをチェックします。値が等しくない場合、条件は真になります。|（A！= B）は真です。|
|>（より大きい）|左のオペランドの値が右のオペランドの値よりも大きいかどうかをチェックし、そうであれば条件が真になります。|（A> B）は正しくありません。|
|<（より小さい）	|左のオペランドの値が右のオペランドの値よりも小さいかどうかをチェックし、そうであれば条件が真になります。|（A <B）は真です。|
|> =（以上）|左のオペランドの値が右のオペランドの値以上かどうかを確認し、はいの場合は条件が真になります。|（A> = B）は正しくありません。|
|<=（以下）|左のオペランドの値が右のオペランドの値以下かどうかをチェックし、そうであれば条件が真になります。|（A <= B）は真です。 |

■ビット演算子
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を保持すると仮定します

|オペレーター	|説明	|例|
|:----:|:----:|:----:|
|＆（ビットごとのand）|バイナリAND演算子は、両方のオペランドに存在する場合、結果にビットをコピーします。|（A＆B）は0000 1100である12を与えます|
|｜ （ビット単位または）	|いずれかのオペランドにビットが存在する場合、バイナリOR演算子はビットをコピーします。	|（A ｜ B）は、0011 1101である61を返します。|
|^（ビットごとのXOR）|バイナリXOR演算子は、両方ではなく1つのオペランドにビットが設定されている場合、ビットをコピーします。	|（A ^ B）49を返します（0011 0001）|
|〜（ビットごとの賛辞）	|Binary Ones Complement Operatorは単項演算子であり、「反転」ビットの効果があります。	|（〜A）は、-61を返します。これは、符号付き2進数による2の補数形式で1100 0011です。|
|<<（左シフト）|バイナリ左シフト演算子。左のオペランドの値は、右のオペランドで指定されたビット数だけ左に移動します。|<< 2の場合、240は1111 0000になります|
|>>（右シフト）|バイナリ右シフト演算子。左のオペランドの値は、右のオペランドで指定されたビット数だけ右に移動します。	|>> 2は15を与え、これは1111です。|
|>>>（ゼロフィル右シフト）|右ゼロ詰め演算子をシフトします。左のオペランドの値は、右のオペランドで指定されたビット数だけ右に移動され、シフトされた値はゼロで埋められます。	|>>> 2は15を与えます。これは0000 1111です。|

■論理演算子
次の表は、論理演算子を示しています

ブール変数Aがtrueを保持し、変数Bがfalseを保持すると仮定します。

|オペレーター	|説明	|例|
|:----:|:----:|:----:|
|&&（論理的および）	|論理AND演算子が呼び出されました。両方のオペランドがゼロ以外の場合、条件は真になります。	|（A && B）は偽です|
|｜｜（論理的または）	|論理OR演算子と呼ばれます。2つのオペランドのいずれかがゼロ以外の場合、条件は真になります。	|（A ｜｜ B）は真|
|！（論理的ではない）	|論理否定演算子と呼ばれます。オペランドの論理状態を反転するために使用します。条件が真の場合、論理否定演算子は偽になります。	|！（A && B）はtrue|

■割り当て演算子
以下は、Java言語でサポートされている割り当て演算子です。

|オペレーター	|説明	|例|
|:----:|:----:|:----:|
|=	単純な代入演算子。|右側のオペランドから左側のオペランドに値を割り当てます。|	C = A + Bは、A + Bの値をCに割り当てます|
|+ =	|AND代入演算子を追加します。|右オペランドを左オペランドに追加し、結果を左オペランドに割り当てます。	|C + = AはC = C + Aと同等です|
|-=	減算AND代入演算子。|左オペランドから右オペランドを減算し、結果を左オペランドに割り当てます。	|C-= AはC = C – Aと同等です|
|* =	|乗算AND代入演算子。|右オペランドと左オペランドを乗算し、結果を左オペランドに割り当てます。	|C * = AはC = C * Aと同等です|
|/ =	|除算AND代入演算子。|左のオペランドを右のオペランドで除算し、結果を左のオペランドに割り当てます。	|C / = AはC = C / Aと同等です|
|％=	モジュラスAND代入演算子。|2つのオペランドを使用してモジュラスを取得し、結果を左のオペランドに割り当てます。	|C％= AはC = C％Aと同等です|
|<< =	|左シフトAND代入演算子。	|C << = 2はC = C << 2と同じです|
|>> =	|右シフトAND代入演算子。	|C >> = 2はC = C >> 2と同じです|
|＆=	|ビット単位のAND代入演算子。	|C＆= 2はC = C＆2と同じです|
|^ =	|ビットごとの排他的ORおよび代入演算子。	|C ^ = 2はC = C ^ 2と同じです|
|=	|ビット単位の包括的ORおよび代入演算子。	|C = 2はC = C |と同じです 2|

■その他の演算子

- 条件演算子（？：）
条件演算子は、三項演算子とも呼ばれます。演算子は次のように書かれています。

```
variable x = (expression) ? value if true : value if false
```
例：

```ruby:java
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 );
   }
}
```

- instanceof演算子
この演算子は、オブジェクト参照変数にのみ使用されます。
オペレーターは、オブジェクトが特定のタイプ（クラスタイプまたはインターフェースタイプ）であるかどうかをチェックします。
instanceof演算子は次のように記述されます。

```
( Object reference variable ) instanceof  (class/interface type)
```

例：

```ruby:java
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 );
   }
}
```
##0208.Java-ループ制御
一般的に、ステートメントは順番に実行されます。関数の最初のステートメントが最初に実行され、次に2番目のステートメントが実行されます。
プログラミング言語は、より複雑な実行パスを可能にするさまざまな制御構造を提供します。
**ループ文**では、私たちはステートメントのステートメントまたはグループを実行するために複数回を可能にし、以下のプログラミング言語のほとんどでループ文の一般的な形式です。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/ff13ee3d-5b81-d6df-8385-3b014b7bdf53.png)

Javaプログラミング言語は、ループ要件を処理するために次のタイプのループを提供します。次のリンクをクリックして、詳細を確認してください。

|ID|ループと説明|
|:----:|:----:|
|1 |whileループ 特定の条件が真である間、ステートメントまたはステートメントのグループを繰り返します。ループ本体を実行する前に条件をテストします。|
|2|forループ  一連のステートメントを複数回実行し、ループ変数を管理するコードを短縮します。|
|3|do ... whileループ  whileステートメントに似ていますが、ループ本体の最後で条件をテストします。|

##0209.Java-条件分岐

プログラムによって評価またはテストされる1つ以上の条件と、条件が真であると判定された場合に実行されるステートメント、およびオプションで、条件が判定された場合に実行される他のステートメントがあります偽りです。
以下は、ほとんどのプログラミング言語で見られる典型的な意思決定構造の一般的な形式です。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/185058/2a3de3ba-52a7-c2b0-dd49-61db59b98365.png)

Javaプログラミング言語は、次のタイプの意思決定ステートメントを提供します。次のリンクをクリックして、詳細を確認してください。


|ID|ステートメントと説明|
|:----:|:----:|
|1|ifステートメント if文は、 1つ以上の文が続くブール式で構成されています。|
|2|if ... elseステートメント;if文は、オプションを続けることができelse文ブール式が偽のときに実行されます。|
|3|ネストされたifステートメント;1つのifまたはelse ifステートメントを別のifまたはelse ifステートメント内で使用できます。|
|4|switchステートメント;スイッチステートメントは、変数が値のリストに対して平等のためにテストすることを可能にします。|

？：オペレーター

```ruby
Exp1 ? Exp2 : Exp3;
```
##0210.Java-数値クラス
##0211.Java-文字クラス
##0212.Java-文字列クラス
##0213.Java-配列
##0214.Java-日付と時刻
##0215.Java-正規表現
##0216.Java-メソッド
##0217.Java-ファイルとI / O
##0218.Java-例外
##0219.Java-内部クラス
#03. Javaオブジェクト指向

#04. Java高級
#05. プロジェクト開発
lvs:四层负载
nginx:四层/七层都可
Haproxy：四层/七层都可

nginx：万级别
lvx：十万级别

需要考虑的因素如下：

1，HTTP/HTTPS/TCP/UDP,4层负载还是7层负载

2,服务器端负载均衡还是客户端负载均衡

3，高峰期是否可以水平扩展

4，健康检查的参数配置

5，能进行什么类型的会话保持

6，多域名的会话保持开启和关闭规则配置

7，会话如何开启，持续时间多久？

8，怎么获得来访者的真实IP

9，允许开放哪些端口？

10，支持哪些转发方式？

11，最多支持几台服务器负载均衡？

12，不同操作系统可以做负载均衡吗？

13，可以在使用负载均衡的过程中，随时调整后端服务器的数目吗？

14，同组服务器可以搭建多少个网站，并同时进行负载均衡吗?

15,是否支持跨地域部署

16，是否支持白名单

17,负载均衡后端服务器间，如何实现数据同步

18，能否监听相关变化？

19，负载均衡支持的证书格式及转换方式

手順書→移行作業概要シート⇒作業手順書
カテゴリーーー空白ーーー計画ーーーーー作業実績ーーーーーーーーーー確認実績
作業項目（小項目）ーーークライアントーーーユーザIDーーー作業内容ーーーテキストーーー「作業日ー開始時刻ー終了時刻ー作業者ー作業結果」ーーー「確認者ー遅延ー確認結果」

SWAT:Subjective Workload Assess-ment Technique主观工作量评估技术