day02 -- Java の基本プログラミング: 変数、データ型、型変換、操作ルール、スキャナー、演算子、分岐構造、ループ (乱数)、メソッド、オーバーロード、変数パラメーター、再帰、配列、バブル ソート

1 Day02 – 変数 + データ型 + 型変換

1.1 序文

1.1.1 識別子

単純に名前として理解できます。Java では、パッケージ名、クラス名、メソッド、フィールド、変数など、コードの多くの要素を識別する必要があります。私たちが選択する名前は識別子と呼ばれ、次の規則に従います。

• A. 識別子は文字、数字、アンダースコア (_)、ドル記号 ($) で構成できますが、@、%、スペースなどの他の特殊文字を含めることはできません。
• B. 数字で始めることはできません。
• C.識別子では大文字と小文字が厳密に区別されます。
• D. 識別子には、その機能を反映し、英語で理解しやすい名前を付けることが最善です。
• E. 中国語の名前を書くこともできますが、一般的には推奨されません。また、非常に低いピンインの使用も推奨されません。

1.1.2 キーワード

Java 言語で特定の意味が与えられているいくつかの単語。キーワードは全部で53個あります。const (定数、変更されない) と goto (go to) という 2 つの予約語があります。キーワードを識別子として使用することはできません。！
予約語: 現時点では使用されていませんが、将来的に使用される可能性があります。
キーワード内の文字はすべて小文字です。

Java には多くのキーワードがあるため、プログラムをコンパイルするときにキーワードを識別子として使用すると、コンパイラーがエラーを通知するため、無理に覚える必要はありません。

1.1.3 コメント

1) Java仕様の3つのアノテーションメソッド：

//  单行注释               （快捷键：ctrl+/, 取消注释：重复使用一次）
/*  多行注释  */            (快捷键：ctrl+shift+/),取消注释：重复使用一次
/** 文档注释(java特有)  */  (快捷键：/**+enter)

使用位置：
类上，类的属性上，类的方法上-----推荐使用文档注释
方法内部----推荐使用单行、多行注释

2) 単一行コメントと複数行コメント：
2.1) 機能:

1. Javaコードの説明。これはプログラムの実行には影響せず、プログラムの読み取りを支援するために使用されます。
2. 書いたコードをデバッグする

2.2) 特徴:
単一行のコメントと複数行のコメント、コメントされた内容はコンパイルに参加しません。
つまり、コンパイル後に生成される .class で終わるバイトコード ファイルには、コメントアウトされた情報は含まれません。

2.3) 注意事項:複数行コメントは入れ子にできません 他のコメントは入れ子にできますが意味がありません。

3). 文書のコメント：
3.1) 機能:注釈の内容は、JDK が提供するツール javadoc によって解析され、Web ページ ファイルの形式でプログラムのドキュメントのセットを生成できます。
3.2) ケース:

独自の API ドキュメントを生成します。コマンド ラインまたはアイデアなどの開発ツールを通じて、詳細については Baidu を確認してください。



注文：javadoc 参数 文件

1.1.4 Eclipseのショートカットキー

Ctrl キーを押しながらマウスをクリックしてソース コードを表示します。
syso+alt+/: 出力ステートメントのショートカット キー
ctrl +/: コードの複数行を選択し、単一行のコメントをすばやく追加します。（キャンセル、もう一度ショートカットキーを使用します）
Ctrl+shift+o：パッケージをインポートするショートカットキー
Ctrl+d：一度に1行削除するショートカットキー（削除するコードブロック内で、ショートカットキーを使用して行を削除します） )
Ctrl +n ショートカット キー 上下キーを使用した new と同等 (マウスを使用せずにプロジェクト、パッケージ、クラスを作成)
Alt+上下矢印 (コードを上下に移動)

1.1.5 Java のエスケープ文字

エスケープ文字: 特別な記号または特別な意味を表すために使用されます。
\b: 1 文字戻ることを意味します
\t: タブストップを意味します
\n: 次の行に切り替えることを意味します
\r: キャリッジ リターン

\": 二重引用符を表します
\': 一重引用符を表します
\: バックスラッシュ文字を表します\

1.1.6 Javaでの出力文

System,out.print();   //输出不换行
System,out.println();   //换行
System,out.println(“ ”);//输出一个空格
System,out.println(“\t”); //对齐：输出的数加上空格一共8位。也可以改为（“     “）的形式。

1.1.7 変数 (デフォルト)

例：
部屋---------- 変数
部屋名---------- 変数名
部屋タイプ---------- 変数タイプ
宿泊人数----------変数値

概念: JAVA では、一部のデータ値は固定されず常に変化しますが、これらの値も記録する必要があり、これらの値を変数として理解することができます。

変数の本質: 変数は実際にはメモリ空間の一部です。変数を作成するとき、それはオペレーティング システムからメモリ空間の一部を申請することを意味します。異なるタイプの変数を宣言することは、本質的に異なるサイズのメモリを申請することを意味します。 space; (プログラム実行の最初のステップ。1 つのステップは、メモリをメモリにロードし、次にプログラムの実行とハードウェアの関係を追跡することです)

変数を使用するための原則：近接性の原理に基づき、最小範囲での制御を試みます。

変数の宣言:変数の型 変数名 = 変数の値。
= : 代入番号。右側のデータが左側の変数に代入されます。

int num = 18;   //声明的同时赋值

等价于：

int num;  //先声变量
num = 20;//在进行赋值

注:

1. 変数名は有効な識別子である必要があります。
2. 変数名には java キーワードを使用できません。
3. 同じスコープ内で変数名を繰り返すことはできません。
4. Java の句読点は英語です。
5. 変数は各文をセミコロンで終了します。

Java での変数の使用規則:

1. Java の変数は使用前に宣言する必要があります。(ローカル変数にはデフォルト値がないため、出力に使用する場合は、使用する前に宣言して値を割り当てる必要があります。メンバ変数にはデフォルト値があり、それを出力したい場合には値を代入せずに出力することもできます。）
2. 変数を使用する場合、変数を宣言しながら初期化することもできます (初期化: 最初の代入)。または、最初に変数を宣言してから代入することもできます。
3. 変数に一度に割り当てられる値は 1 つだけですが、複数回変更できます。
4. Main メソッドで定義された変数には、出力する前に値を割り当てる必要があります。
5. 構文に誤りはありませんが、実際の開発において変数名に中国語を使用することは、後のクロスプラットフォーム操作で文字化けなどのセキュリティリスクが発生しやすいため、推奨されません。
6. 変数の使用はデータ型と一致する必要があります。
7. 変数はそのスコープ内で定義されます。範囲内であれば有効です。つまり、範囲外になると無効になってしまいます。
8. 変数範囲スコープ: 変数の宣言から最も近い { } が含まれますプログラムは終了します。
9. 変数の命名規則: キャメルケース「score、myScore、myJavaScore (2 番目の単語の最初の文字は大文字)」。

変数の分類:

1. 宣言された位置に従って分割されます: 成员变量(クラス内のメソッドの外側) と局部变量(メソッドの内側)。メンバー変数は次のように分割されます:实例变量と静态变量(静的キーワードを追加)
2. データ型:基本数据类型と で分割されます引用数据类型(类，接口，数组)。

ローカル変数:

1. メソッド (メソッド パラメーターを含む) またはローカル コード ブロックで定義。
2. メモリを割り当てるには手動で初期化する (初期値を割り当てる) 必要があります。例: int i=5;
3. スコープはメソッドまたはローカル コード ブロック内で、メソッドの実行後にメモリが解放されます。

メンバー変数:

1. クラス内のメソッドの外で定義されます。
2. 初期化は必要なく、自動的にデフォルト値に初期化されます。
3. スコープはクラス全体内で、クラスが消滅すると変数は解放されます。

メンバー変数のデフォルト値:

1).参照型(基本8型を除く) : デフォルト値はnull
2).基本型:
そのうちchar: /u0000 (デフォルト値、通常は表示されません。空白文字のコードは0x20で、以下のコードです) 0x20 は非表示の制御文字です。一部のシステムでは、非表示の文字に遭遇するとボックスを出力して、非表示の文字に遭遇したことを示します)

基本タイプ	デフォルト値
バイト	0
ショット	0
整数	0
長さ	0L
浮く	0.0f
ダブル	0.0d
ブール値	間違い

1.1.8 定数

day03 - 3.3 --final で学習した定数。

概要: プログラムの実行中に変化しない量が定数になります。

定数の定義形式: final 数据类型 常量名 = 值;。通常、外部呼び出しを容易にするために、定数は static によって変更され、クラス名によって直接アクセスできます。最終的な形式は次のとおりですpublic static final 数据类型 常量名 = 值;。

定数の命名規則:定数名のすべての文字を大文字にし、複数の単語をアンダースコア (「_」) で区切ることをお勧めします (推奨されますが必須ではありません)。例: MAX_VALUE

定数に関する注意:

1. 同時に初期化するように宣言する必要があります (初期値は直接割り当てる必要があり、変更できません) (静的ブロックでの代入も可能ですが、推奨されません)
2. これはクラス名ポイントを介してアクセスされ、変更できません。

定数の利点: コンパイル時に定数が特定の値に直接置き換えられる - 高効率

定数はいつ使用されますか? データは決して変更されず、頻繁に使用されます。

1.1.9 変数テストケース

//测试一：
package cn.tedu.variable;
 
		import org.junit.Test;
 
		//测试 变量的使用
		public class Test6_Variable {
    
    
			//TODO 测试其他类型 的默认值
			
			//2,成员变量:位置是在类里方法外  +  有默认值 + 作用范围是整个类里
			double count ;
			
			//3,就近原则---前提是---当成员变量 和 局部变量同名时,你使用的一定是局部变量
			int sum = 20 ;
			
			//单元测试junit :要求方法要有标志@Test + 方法必须是public的 + 方法返回值是void，没有参数列表
			@Test    //需要导包（1 2 都可以）
			public void show() {
    
    
				//1,局部变量:位置是在方法里 + 必须初始化  + 作用范围是方法里
				int sum = 10;
				System.out.println(sum);//10,就近原则
				System.out.println(count);//0.0
			}
			
			
		}
 
 
 
 
//测试二： 
package cn.tedu.arrays;
 
public class Test2_Variable {
    
    
	
	//1、成员变量：在类里方法外
	//作用范围就是整个类里
	//可以不初始化，也会有默认值
	int age = 20;
	
	int sum = 30;
	
	public static void main(String[] args) {
    
    
		//2局部变量：在方法里
		//作用范围就是方法里，出了这个方法就不认识了
		//必须初始化
		int sum = 10;
		System.out.println(sum);//10
		
		//3、变量的就近原则，附近有同名的会去执行最近的
		System.out.println(sum);//10
	}
}

1.1.10 メンバ変数の注意事項

注: メンバー変数を最初に宣言してから割り当てることはできません。

説明: メンバー変数はクラスのスコープ内にあり、ヒープ メモリに存在し、デフォルトの初期値を持ち、宣言時に値が割り当てられています。繰り返しになりますが、「代入」では実際にはステートメントが使用され、クラス本体に出現できるのは変数とメソッドのみであり、ステートメントは出現しません。

package com.cn.ins;

public class Aa {
    
    
	
	private int age = 10;
	int b;
	b= 20;//报错:成员变量不能先声明后赋值。
	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub

	}

}

1.2 データ型

厳密に型指定された言語: 規制に厳密に準拠するために変数を使用する必要があり、使用する前にすべての変数を定義する必要があります。例: Java、.net、Python、C++、その他の言語。

弱い型指定言語: データ型を無視できる言語。これは、変数にさまざまなデータ型の値を割り当てることができる、厳密に型指定された定義言語の逆です。例: vb、PHP、JavaScript、その他の言語。

Java データ型は、次の 2 つの主要なカテゴリに分類されます。

1. 基本的なデータ型:変数にはデータそのものが格納されます。(引き出しの中身と同等)
2. 参照データ型: (基本型を除く、クラス、インターフェイス、配列などのすべての参照型) 変数は次の場所に格納されます。データが保存されている空間アドレス。（引き出しの鍵に相当）

1.2.1 基本タイプ（8種類）

小さいものから大きいものへのソート: byte short (char) int long float double
説明: Boolean 型はソートに関与せず、char は自動的に int に変換されます。
用語集：バイトとは。

1.2.2 演習 1: 最大値と最小値

package day0102;
//总结
//1,基本类型：byte short int    long   float  double char   boolean
//2,工具类：Byte Short Integer  Long   Float  Double Character Boolean       
//3,工具类提供了很多功能，其中就包含了大小值   
//基本类型对应的包装类提供了一些功能，最大值，最小值 没有括号不是方法
//注意包装类首字母大写，尤其2个特殊
 
public class Test1 {
    
    
	public static void main(String[] args){
    
    
		
		//=====1、整型测试开始
        //变量类型  变量名 = 变量值
		byte a=-128;   打印变量的值，不需要" "
		byte b=127;
		
		short c=Short.MIN_VALUE;
		short d=Short.MAX_VALUE;
		
		int e=Integer.MIN_VALUE;
		int f=Integer.MAX_VALUE;
		
		long g=Long.MIN_VALUE;
		long h=Long.MAX_VALUE;
		
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
		System.out.println(f);
		System.out.println(g);
		System.out.println(h);
		//=====整型测试结束
		
		//=====2、浮点测试开始
		/**
		 *float是单精度，对小数运算不精确。double是双精度，对小数运算精确。
		 *对于编程人员来说，double和float的区别是double精度高，但double消耗内存是float的两倍。
		 *且double的运算速度较float稍慢。
		 */
		float i=Float.MIN_VALUE; //1.4E-45（代表10的负45次方）
		float j=Float.MAX_VALUE; //3.4028235E38(代表10的38次方)
 
		double k=Double.MIN_VALUE; //4.9E-324
		double l=Double.MAX_VALUE; //1.7976931348623157E308
		System.out.println(i);
		System.out.println(j);
		System.out.println(k);
		System.out.println(l);
		//=====浮点测试结束
		
 
       //=====3、字符测试开始
       /**
       *字符char    单引号
       *字符串String（S大写）   双引号
       */ 
       
       //① 定义char型变量，通常使用一对'',内部只能写一个字符   
       char c  = 'a';   //可以存一个字母或者数字或者符号不能没有，可以是空格
       char c4 ='1';   //数字也只能存一个。
       char c2 = 97;   //可以直接存数字（可以写多个数字）
       char c3 = '中'; //可以存一个中文汉字
      
       //char类型可以存一个数字，但是在使用时，并不是使用了数字本身，而是去查数字对应的字符，然后使用字符。
       //ascii码表，规定了数字和字符的对应关系。其中数字97就是对应了字符a。 97----a    65---A    48---0
       //ascii码表里，规定了0~127数字对应的字符，char类型的取值
	   //范围是0~65535.那么从128~65535默认对应的字符是?.
       System.out.println(c);
       System.out.println(c2);//a
       System.out.println(c3);
       
	   //② 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
		char c5 = '\n';//换行符
		c5 = '\t';//制表符
		System.out.print("hello" + c5);
		System.out.println("world");

		char c6 = '\u0043';
		System.out.println(c6);
      
      
       //=====4、布尔
 	   //① 只能取两个值之一：true 、 false
	   //② 常常在条件判断、循环结构中使用
       boolean b = true;
       boolean b2 = false;
		
	}
}

//long start = System.currentTimeMillis()用于获取自1970.1.1零时到此时此刻的毫秒数，返回值类型为long类型·

1.2.3 演習 2: 個人情報を入力する

Wang Haitao さんは今年 20 歳、月給 20,000 で、できるだけ早く人生の頂点に達するために、Java を一生懸命勉強するようにとアドバイスしています。

package day0201_规则;

import java.util.Scanner;
 
public class Test1_个人信息 {
    
    
 
	public static void main(String[] args) {
    
    
	
		System.out.println("姓名：");
		String name= new Scanner(System.in).nextLine();
		//注意：String对应的是Line
		System.out.println("性別：");
		String gender= new Scanner(System.in).nextLine();
		
		System.out.println("年龄：");
        //其它的都是首字母大写
		int age= new Scanner(System.in).nextInt();
		
		
		System.out.println("您输入的个人信息是：");
		System.out.println("姓名："+name);
		System.out.println("性別："+gender);
		System.out.println("年龄："+age);
		
	}
	
}

1.2.4 演習 3: String 型変数の使用

/*
String类型变量的使用
1. String属于引用数据类型,翻译为：字符串
2. 声明 String类型变量时，使用一对""
3. String可以和 8种基本数据类型变量做运算，且运算只能是连接运算：+
4. 运算的结果仍然是String类型

*/
class StringTest {
    
    
	public static void main(String[] args) {
    
    
		
		String s1 = "Hello World!";

		System.out.println(s1);

		String s2 = "a";
		String s3 = "";

		//char c = '';//编译不通过

		//***********************
		int number = 1001;
		String numberStr = "学号：";
		String info = numberStr + number;// +：连接运算
		boolean b1 = true;
		String info1 = info + b1;// +：连接运算
		System.out.println(info1);

		//***********************
		//练习1
		char c = 'a';//97   A:65
		int num = 10;
		String str = "hello";
		System.out.println(c + num + str);//107hello
		System.out.println(c + str + num);//ahello10
		System.out.println(c + (num + str));//a10hello
		System.out.println((c + num) + str);//107hello
		System.out.println(str + num + c);//hello10a

		//练习2
		//*	*
		System.out.println("*	*");
		System.out.println('*' + '\t' + '*');
		System.out.println('*' + "\t" + '*');
		System.out.println('*' + '\t' + "*");
		System.out.println('*' + ('\t' + "*"));


		//***********************

		//String str1 = 123;//编译不通过
		String str1 = 123 + "";
		System.out.println(str1);//"123"
		
		//数字类型不能和字符串类型进行 自动和强制类型转换
		//int num1 = str1;
		//int num1 = (int)str1;//"123"
        
        //基本类型和引用类型，可以使用包装类进行转换
		int num1 = Integer.parseInt(str1);
		System.out.println(num1);//123
	}
}

1.2.5 演習 4: 文字列の接続プロセス。

みなさん、こんにちは。私の名前はZha Zhahui、28歳です。

package cn.tedu.basic;
//这个类用来测试字符串拼接
public class Test2_Info {
    
    
    public static void main(String[] args) {
    
    
      
       //值是一串，Java里表示一串数据，就是String类型。
       String name = "蔡徐坤";
      
       byte age = 28;
      
       //通过+拼接字符串，  "+?+"
       System.out.println("大家好，我叫"+name+"，今年"+age+"。");
      
    }
}
 

1.2.6 演習 5: 円の面積

円の面積：π*r*r
円周：2*π*r

package day0104;
 
import java.util.Scanner;
 
public class Test1 {
    
    
 
	public static void main(String[] args) {
    
    
		  //定义变量，记录半径r
//           double r = 10.1;//不好，值写死了。
              //动态的接受键盘输入的值
              //测试时：console试图中小红点常亮，表示等待用户的输入，输入完毕后敲回车，表示输入结束。
              double r = new Scanner(System.in).nextDouble();
             
              double result = 3.14*r*r;//带入公式
              System.out.println(result);
             
//或者    System.out.println(3.14*r*r);
             
       }
      
}

1.2.7 演習6: 変数交換(3種類)

ユーザーが入力した値を受け取ります: a=1、b=2 と仮定し、a と b の値を交換します。

package day0103;
 
import java.util.Scanner;
 
 
public class Test1 {
    
    
 
	public static void main(String[] args) {
    
    
	案例1：
    //1，接受键盘输入整数a和整数b
		System.out.print("输入整数a:");
		int a=new Scanner(System.in).nextInt();
		//前后对照
		System.out.print("输入整数b:");
		int b=new Scanner(System.in).nextInt();
		//第一种方式：
		//2.开始交换
		int t=a;   //把a的值给t     首尾相连
		a=b;      //把b的值给a
		b=t;      //把t的值给b                                                                                                                                                                                                                                                                                       
		System.out.println(a);
		System.out.println(b);
	}
       //第二种方式：a=a+b; b=a-b;a=a-b 另一种2个数进行交换
 
}



案例2：
//练习：交换两个变量的值
		int num1 = 10;
		int num2 = 20;
		System.out.println("num1 = " + num1 + ",num2 = " + num2); //num1 = 10,num2 = 20

		//方式一：定义临时变量的方式
		//推荐的方式
		int temp = num1;
		num1 = num2;
		num2 = temp;

		//方式二：好处：不用定义临时变量  
		//弊端：① 相加操作可能超出存储范围 ② 有局限性：只能适用于数值类型
		//num1 = num1 + num2;
		//num2 = num1 - num2;
		//num1 = num1 - num2;

		//方式三：使用位运算符
		//有局限性：只能适用于数值类型
		//num1 = num1 ^ num2;
		//num2 = num1 ^ num2;
		//num1 = num1 ^ num2;

		System.out.println("num1 = " + num1 + ",num2 = " + num2);//num1 = 20,num2 = 10 

1.3 基本型のデフォルトリテラル型（5項目）

1.3.1 整数リテラル型（デフォルト値）はint型です

int a = 9999999999;//错，右侧是int类型，但是超出范围

1.3.2 int より小さい byte、short、char 整数は、範囲内の値を使用して直接代入できます。

byte b=127;//对
byte b=128;//错，右面已经超过byte范围是int类型的数据
超过范围的相加 加2次最大值等于它本身（所有的基本类型）

1.3.3 浮動小数点数のリテラル値がdouble型である

double  a=3.14;//对
float a=3.14;//错，右面是double，float是四字节double是八字节存不下

1.3.4 リテラル値の接尾辞 lfd

//因为它默认的是int类型虽然可以自动转，但是它超出本身的范围了。所以加上一个L 表示long 类型。
//这个整数默认是int类型，但是超出了int范围，还想使用怎么办？
//加后缀L，用来把字面值是int类型的数据，提升成long类型
L –long   如：long a = 99999999999;//错，超出范围，解决方案加L

//后缀f，用来把默认的double类型的小数，转成float类型
F –float   如：float a = 3.14;//错，右面是double类型，解决方案加F或者(float)

//后缀d，用来把字面值是int类型的3，转成double类型
D –double  如：double a=3;//错，右面是int，解决方案加D或者改成3.0

//后缀一般默认是大写，因为小写有时候想数字1不好区分。
注意不加也不报错，因为3在double类型的取值范围之内。

1.3.5 ベースプレフィックス

0x   - 16进制
0    -8进制
\u   -char类型，16进制
0b   -2进制  0b0011

1.4 基本型の型変換

注:
1. ブール値は変換できません。(対応するエンコード テーブルが数値であるため、char 型は問題ありません。)
2. オブジェクト型を無関係な型に変換することはできません。
3. 大容量から小容量に変換する場合は強制型変換が必要です。
4. 小さな文字から大きな文字へ自動的に変換されます。
5. 変換中にメモリのオーバーフローや精度の問題が発生する可能性があります。

1.4.1 小規模から大規模へ（暗黙的な変換）

キャストは必要ありません

//自动类型转换
Byte a =120;
Int b=a;//直接转    
整形可以转换为浮点型
char可以直接转化为int类型

1.4.2 大から小へ（明示的な変換）

型変換が必要です

//强制类型转换
int xx = 356;
byte y=(byte) xx;

//内存溢出问题
int i=128;
byte b=(byte)i;//-128 内存溢出，byte范围为-128~127


//精度问题：小数转成整数，小数直接舍弃。
 double y = 9.1;
 int x = (int)y;//右侧的y是大类型，给小类型x赋值时，需要强转、
 System.out.println(x);//9，丢弃小数部分
 //不管0.1还是0.9全都舍弃


//char类型的转换
char c='a'; //97
int d=c+1;
System.out.println(d);//98
System.out.println((char)d);//b

1.5 運用ルール（5項目）

1.5.1 計算結果は最大の型と一致するデータ型です

3/2   得1 ，而不是1.5，结果是int类型
3d/2  得1.5，相当于double/int，结果是double类型

1.5.2 byte、short、char は int より小さい 3 つの整数であり、動作時に最初に自動的に int に変換されます。

byte a=3;
byte b=4;
byte c=a+b;//错，运行时，byte会先自动转成int再运算，int+int还是int
byte c = (byte)(a+b);
//右侧的a+b运算时，会自动变成int类型，是大类型。给左面的c小类型赋值？？--不能直接赋值需要强转

1.5.3 整数演算のオーバーフロー

整数演算は、最大値に達してから最小値に戻る時計に似ています。
注意: 比較的大きな数値を演算する場合はオーバーフロー問題に注意してください
解決策: 変数の値の範囲を事前に拡張し、int リテラル値に L 接尾辞を追加して Long 型に展開し、通常は最初の数値の後に L を追加します。

//jdk1.7新特性：数字之间可以用下划线分割，输出时不会影响。
int money=10_0000_0000;
int years=20;
int total=money*years; //内存溢出 -1474836480
long total2=money*years; //内存溢出，计算完后默认是int类型,转换为long之前就出现问题了。 -1474836480		
long total3=(long)money*years;//20000000000
System.out.println(total);
System.out.println(total2);
System.out.println(total3);

//计算：光速运行一年的长度是多少米
System.out.println(300000000*60*60*24*365);
System.out.println(300000000l*60*60*24*365);
//运算结果，字面值就是int类型。但是，已经超出了int取值范围，就会整数运算溢出现象
 //解决方案：把int字面值加L后缀扩大，变成long类型、一般是第一个数后加L。

1.5.4 浮動小数点演算は不正確です

理由: 浮動小数点数の特性は限定的かつ離散的であるため、丸め誤差が発生し、結果はそれに近いですが等しくない約数のみになります。
解決策: Java は、後で説明するBigDecimal という解決策を提供します。

System.out.println(1-0.8);//0.19999999999999996
System.out.println(4.35*100);//434.99999999999994

//最好完全避免使用浮点数进行比较
float f= 0.1f;//0.1
double d=1.0/10;//0.1
System.out.println(f==d);//false

1.5.5 浮動小数点数の特殊な値

Infinity 无穷大  3.14/0  
Nan  not a number  0/0.0
 
//输出结果不能出现这种情况，一旦出现检查代码（分母为0或分子分母都为0）

1.6 拡張

1.6.1 漢字は char 変数に格納できますか?なぜですか?

Java で使用されるエンコーディングは Unicode (特定のエンコーディングを選択せず​​、文字セット内の文字の番号を直接使用します。これが統一する唯一の方法です) であるため、char 型は中国語の文字を格納できます。は 2 バイト (16 ビット) を占めるため、中国語のものを入れても問題ありません。

1.6.2 ユーザーインタラクションスキャナー

注:

1. String は Line に対応し、それ以外はすべて最初の文字が大文字になります。
2. Scanner は、char 型を取得するための関連メソッドを提供しません。取得できる文字列は 1 つだけです。受信に char 型を使用する必要がある場合は、gender.charAt(0) メソッドを呼び出すことができます。

import java.util.Scanner;

/*
如何从键盘获取不同类型的变量：需要使用Scanner类

具体实现步骤：
1.导包：import java.util.Scanner;
2.Scanner的实例化:Scanner scan = new Scanner(System.in);可以写一块
3.调用Scanner类的相关方法（next() / nextXxx()），来获取指定类型的变量

注意：
需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchException
导致程序终止。
*/ 
public class Test1_个人信息 {
    
    
 
	public static void main(String[] args) {
    
    
		System.out.println("姓名：");
		String name= new Scanner(System.in).nextLine();//写一块的写法
		//注意：String对应的是Line
		System.out.println("性別：");
		String gender= new Scanner(System.in).nextLine();
		
		System.out.println("年龄：");
        //其它的都是首字母大写
		int age= new Scanner(System.in).nextInt();
		
		
		System.out.println("您输入的个人信息是：");
		System.out.println("姓名："+name);
		System.out.println("性別："+gender);
		System.out.println("年龄："+age);


		//对于char型的获取，Scanner没有提供相关的方法。只能获取一个字符串
		System.out.println("请输入你的性别：(男/女)");
		String gender = scan.next();//"男"
		char genderChar = gender.charAt(0);//获取索引为0位置上的字符
		System.out.println(genderChar);
		
	}
	
}

出力は次のようになります: こんにちは

出力: hello world

理由:

数値の場合は、対応する nextxxx() メソッドを使用して判断します。

package lianxi;

import java.util.Scanner;

public class Ta {
    
    

	public static void main(String[] args) {
    
    
		Scanner scanner =new Scanner(System.in);
		
		//从键盘接收数据
		int i=0;
		float f=0.0f;
		System.out.println("请输入整数：");
		if(scanner.hasNextInt()) {
    
    
		/*
		* 如果什么也不写默认为true(老手写法)
		* if(scanner.hasNextInt()==true) { 新手写法
		*/
		
			i= scanner.nextInt();
			System.out.println("整数数据"+i);
			
		}else {
    
    
			System.out.println("输入的不是整数数据");
			
		}
		
		scanner.close();
	}

}

2 Day03 – 演算子 + 分岐構造 + ループ

2.1 演算子

2.1.1 概要: 一般的な演算子

2.1.2 ビット演算子

一般的な演算子に加えて、ビットごとの演算子もあります。

&，|，^ それが論理演算子である場合とビットごとの演算子である場合をどのように区別するのですか？
シンボルの両側に論理演算子があり、その結果がブール型の場合、それは論理演算子です。符号が整数で囲まれており、結果が整数の場合、それはビット単位の演算子です。

ケース 1 :

/*
		 A = 0011 1100
		 B = 0000 1101
		 ------------------
		 A&B = 0000 1100   上下2个都是1才为1,否则为0
		 A/B = 0011 1101   上下2个都是0才为0,否则为1
		 A^b = 0011 0001   上下2个位置相同则为0,否则则为1.
		 ~B  = 1111 0010  取反
		 
		 2*8 = 16 2*2*2*2
		 效率极高!!!
		 << *2 左移扩大
		 >> /2 右移缩小
		 0000 0000  0
		 0000 0001  1
		 0000 0010  2
		 0000 0011  3
		 0000 0100  4
		 0000 1000  8
		 0001 0000  16
		 */
		System.out.println(2<<3);//16

ケース 2:

package lianxi;

import java.util.Arrays;

/*
运算符之五：位运算符 （了解）

结论：
1. 位运算符操作的都是整型的数据
2. << ：在一定范围内，每向左移1位，相当于 * 2
   >> :在一定范围内，每向右移1位，相当于 / 2



面试题：最高效方式的计算2 * 8 ？  2 << 3  或 8 << 1
*/
class BitTest {
    
    
	public static void main(String[] args) {
    
    
		int i = 21;
		i = -21;
		System.out.println("i << 2 :" + (i << 2));//i << 2 :-84  不改变符号
		System.out.println("i << 3 :" + (i << 3));//i << 3 :-168
		System.out.println("i << 27 :" + (i << 27));//i << 27 :1476395008

		int m = 12;
		int n = 5;
		System.out.println("m & n :" + (m & n));//m & n :4
		System.out.println("m | n :" + (m | n));//m | n :13
		System.out.println("m ^ n :" + (m ^ n));//m ^ n :9

		

	}
}

2.2 演算子の優先順位

計算式: 単項の乗算と除算は関係であり、値は 3 項の論理の後に割り当てられます。

单目运算符:一次作用一个变量的运算符，又叫一元运算符
单目：单目运算符+ –(正负数) ，++ –，！（逻辑非），~（按位取反）
乘除：算数运算符：* / % + - （* / %优先级肯定是大于+-的）
为：位运算符：~（按位取反）<<(左移) >>(右移)，^（也可以位运算，二进制异或）
关系：关系运算符：> < >= <= == !=
逻辑：逻辑运算符（除！）&& || & | ^
三目：条件运算符A > B ? X : Y
后：无意义，仅仅为了凑字数
赋值：= += -= *= /= %= |= &= ^=
说明：前优先级大于后，比如单目运算符~也是位运算符，~的优先级是单目级别的。至于赋值运算符中没有见过的自行测试

PS: 演算子の優先順位を覚える必要はありませんが、実際の開発では優先順位を管理するために括弧を使用するのが一般的です。のように：

2.3 ケース演習

2.3.1 演習 1: 平年におけるうるう年

输入年号，判断是否是闰年。两个条件：
1、能被4整除，并且不能被100整除
2、或者能被400整除
 
package day0203_平年闰年;
 
import java.util.Scanner;
 
public class Test1 {
    
    
	public static void main(String[] args) {
    
    
		System.out.println("年号：");
		int y = new Scanner(System.in).nextInt(); //1，接受用户输入的年号
 
		
		String r="平年";	//默认都是平年
        //2，判断，这个年号到底是平年还是闰年
 
		if(y%4==0){
    
    
			if(y%100!=0){
    
    
				r="闰年";
			}
		}
		if(y%400==0){
    
    
			r="闰年";
		}
 
 
或者
	   //说明：
       //两个大条件之间是或者的关系，为了高效，用双或
       //大条件1有两个小条件，两个小条件之间是并且的关系，为了高效，用双与
       //能否被整除，要取余数，余数为0就是能整除。余数不是0就是不能整除。
       if( ( year % 4 == 0  &&  year % 100 != 0  ) || year % 400 == 0){
    
    
          
           //如果年号，能满足判断条件，会进来修改r的默认值为闰年。如果没满足，就一直是默认值平年
           r = "闰年";//修改r的值为闰年
 
 
         if((y%4==0&&y%100!=0)||y%400==0){
    
    
			r="闰年";
		  }
 
		System.out.println(y+"年是"+r);
	}
}
 

2.3.2 演習 2: 自己増加と自己減少

package com.jia.jian;

public class JiaJian {
    
    

	public static void main(String[] args) {
    
    
		   //++,--代表自身加一和减一，运算结果与符号顺序有关。
		   //情况1：单独使用时，++ --无论放在变量前还是变量后，结果都是一样的
			int number1 = 10;
			//输出方式一: 输出number1++	
			//System.out.println(number1++);//10
			//输出方式二: 输出number1
			number1++;
			System.out.println(number1);//11
			//总结执行过程：符号在后，先使用后变化(先使用：number1++变为10，后变化：number1自身变为11),
			//所以输出number1++为10，输出number1为11.
		
			int number2 = 10;
			//输出方式一：输出++number2
			//System.out.println(++number2);//11
			//输出方式二：输出number2
			++number2;
			System.out.println(number2);//11
			//总结执行过程：符号在前，先变化后使用(先变化：++number2变为11，后使用：number2自身变为11),
			//所以输出number2++为11，输出number2为11.
			
			int number3 = 10;
			number3--;
			System.out.println(number3);//9
			
			int number4 = 10;
			--number4;
			System.out.println(number4);//9
			
			
			//情况2：参与操作时，符号在后：先使用后变化
			//执行过程：符号在后，先执行运算(先把10赋值给num2),后变化(num1++,num1变为11)
			int num1 = 10;
			int num2 = num1++;
			System.out.println("num1:"+num1+",num2:"+num2);//num1:11,num2:10
			
			//情况3：参与操作时，符号在前：先变化后使用
			//执行过程：符号在前，先变化(++num3,num3变为11),后执行运算(在把11赋值给num4),
			int num3 = 10;
			int num4 = ++num3;
			System.out.println("num3:"+num3+",num4:"+num4);//num3:11,num4:11
				     

	}

}

2.3.3 演習 3: 2 つの数値の大きい方の値を見つけます

/*
三元运算符：
1.结构：(条件表达式)? 表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
  如果表达式为true，则执行表达式1。
  如果表达式为false，则执行表达式2。
③ 表达式1 和表达式2要求是一致的。
④ 三元运算符可以嵌套使用

3. 
凡是可以使用三元运算符的地方，都可以改写为if-else
反之，不成立。

4. 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。
*/
package cn.tedu.basic;
 
import java.util.Scanner;
 
//这个类用来测试两个数里的大值
public class Test3_Max {
    
    
    public static void main(String[] args) {
    
    
       //1，接受键盘输入的两个整数
       //注意：scanner可以直接写，然后三目运算符boolean是他的返回值，前面可以写其他的类型来接受
       int a = new Scanner(System.in).nextInt();
       int b = new Scanner(System.in).nextInt();
      
       //2，比大小  1  ？  2  ：3 ，1判断完如果成立，得到的结果就是2
       //a > b成立的话，把a交给max记录，否则，把b交给max记录
       int max = a > b ? a : b ;
      
       System.out.println(max);
 
    }
}

2.3.4 演習 4: 3 つの数値の最大値を求めます

package day0203_平年闰年;
 
import java.util.Scanner;
 
public class Test1_三个数的最大值 {
    
    
 
	public static void main(String[] args) {
    
    
		
		System.out.println("整数a:");
		int a = new Scanner(System.in).nextInt();
		
		System.out.println("整数b:");
		int b = new Scanner(System.in).nextInt();
 
		System.out.println("整数c:");
		int c = new Scanner(System.in).nextInt();
		
        int max = a>b?a:b;
		max=max>c?max:c;  //分开写
 
     或者
        int max = a>b?(a>c?a:c):(b>c?b:c);    //合一块写
		System.out.println(max);	
	}
}

2.3.5 演習 5: べき乗

//2^3  2*2*2=8 很多运算我们会借助一些工具类来操作。
double pow=Math.pow(3,2);
System.out.println(pow);

2.3.6 演習 6: 複合代入演算子

遅延書き込み方式、強力な転送関数を内蔵。

例1：
        int a=10;
        int b=20;
        a+=b; //a=a+b;
        a-=b; //a=a-b
        System.out.println(a);//30
例2：
        byte a = 1;
//		a=(byte) (a+4);//右侧int，左侧byte，大转小，强转。
//		a=(byte) (a+4);//右侧int，左侧byte，大转小，强转。
		a+=4;//会自动完成数据类型的转换  
		//注意：a=a+4和a+=4是有区别的！！
		System.out.println(a);

2.3.7 演習 7: 文字列連結文字「+」

//字符串连接符：若+一端为字符串，则会转化为Sring类型并进行拼接。
int a=10;
int b=20;
System.out.println(" "+a+b);//1020
System.out.println(a+b+" ");//30
		

2.3.8 演習 8: 論理演算子の短絡問題のテスト

論理演算子: & と &&、| と || の関係。
& 式が評価されると、両方のオペランドが評価され、&& は演算子のショートカットに似ています。&& 式が評価される場合、最初のオペランドが最初に評価され、true を返す場合は 2 番目のオペランドが評価されます。最初のオペランドが false と評価された場合、2 番目のオペランドは評価されません。

一般在程序中想要表示true或者false，可以用1表示true，用0表示false
 
单与：&  --  表示并且的关系
    1 & 2 -- 1和2都为true，结果为true
 
单或：|  --  表示或者的关系
    1 | 2 -- 1和2有一个为true，结果为true
 
双与/短路与：&& --  表示并且的关系，高效
    1 && 2 -- 2会被短路，前提是1为false
 
双或/短路或：|| --  表示或者的关系，高效
    1 || 2 -- 2会被短路，前提是1为true
 
真  &  真  -》真
真  &  假  -》假
假  &  真  -》假
假  &  假  -》假
 
假  |  假  -》假
假  |  真  -》真
真  |  假  -》真
真  |  真  -》真

package lianxi;

import java.util.Arrays;
/*
运算符之四：逻辑运算符

&  && |  || ! ^

说明：
1.逻辑运算符操作的都是boolean类型的变量


*/
class LogicTest {
    
    
	public static void main(String[] args) {
    
    
		
		//区分& 与 &&
		//相同点1：& 与  && 的运算结果相同
		//相同点2：当符号左边是true时，二者都会执行符号右边的运算
		//不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
		//开发中，推荐使用&&
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		if(b1 & (num1++ > 0)){
    
    
			System.out.println("我现在在北京");
		}else{
    
    
			System.out.println("我现在在南京");
		}

		System.out.println("num1 = " + num1); //我现在在南京   num1 = 11
		

		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		if(b2 && (num2++ > 0)){
    
    
			System.out.println("我现在在北京");
		}else{
    
    
			System.out.println("我现在在南京");
		}

		System.out.println("num2 = " + num2); //我现在在南京   num2 = 10
		

		// 区分：| 与 || 
		//相同点1：| 与  || 的运算结果相同
		//相同点2：当符号左边是false时，二者都会执行符号右边的运算
		//不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
		//开发中，推荐使用||
		boolean b3 = false;
		b3 = true;
		int num3 = 10;
		if(b3 | (num3++ > 0)){
    
    
			System.out.println("我现在在北京");
		}else{
    
    
			System.out.println("我现在在南京");
		}
		System.out.println("num3 = " + num3);//我现在在北京  num3 = 11
		


		boolean b4 = false;
		b4 = true;
		int num4 = 10;
		if(b4 || (num4++ > 0)){
    
    
			System.out.println("我现在在北京");
		}else{
    
    
			System.out.println("我现在在南京");
		}
		System.out.println("num4 = " + num4);// 我现在在北京  num4 = 10
		
	}
}

2.4 分岐構造 1: if

2.4.1 概要

問題点：逐次構造のプログラムは、計算や出力などの問題は解決できますが、判断や選択ができません。最初に判断してから選択する必要がある問題の場合は、分岐構造を使用する必要があります。

要約:
複雑なプログラム ロジックは、次の 3 つの構造によって実現できます。
1) シーケンシャル構造: 上から下へ 1 行ずつ実行され、各文を実行する必要があります
。 2) 分岐構造: 条件付きで特定の文を 1 回実行します。すべての文を実行する必要はありません。 Go
3) ループ構造: 条件付きで特定のステートメントを複数回実行します。すべてのステートメントを実行する必要はありません。

2.4.2 フォーム

单分支：满足判断条件，则执行大括号里面的内容。
注意：判断条件又叫条件表达式
条件表达式:结果是boolean。
if(判断条件/条件表达式){
    
    
	代码。。。
}

双分支：
if(判断条件){
    
    
	代码1。。。
}else{
    
    
	代码2。。。
}

多分支：

if(判断条件1){
    
    
	代码1。。。
}else if(条件2){
    
    
	代码2。。。
} else if(判断条件3){
    
    
	代码3。。。
}else{
    
    
	代码4。。。
}

嵌套分支：
if(判断条件){
    
    
 if(判断条件){
    
    
    代码
 }
} 

注意事項:

1. if ステートメントには多くても 1 つの else ステートメントがあり、else ステートメントは他のすべての if ステートメントの後に続きます。
2. if ステートメントには複数の else if ステートメントを含めることができ、それらは else ステートメントの前に置く必要があります。
3. else ステートメントの 1 つが true を検出すると、他の else if ステートメントと else ステートメントは実行されなくなります。
4. 条件構造の場合、中括弧が省略されている場合、コードの最初の文にのみ有効になります (そして、最初のセミコロンの終わりまで中括弧がない場合)。つまり、次の文が 1 つだけある場合、条件構造内のコード、中括弧は省略できます。ただし、省略することはお勧めできません。
5. それ以外はオプションです。
6. ブランチをネストできる場合

2.4.3 演習 1: 製品の割引

ユーザーが入力した元の価格を受け取ります。1,000個以上のご注文で10％オフとなります。2,000以上購入で20％オフ。5,000以上の購入で50％オフ。

注: Java では複数の条件を a>b>c のように記述することはできませんが、論理演算子 a>b&&b>c を使用して出力する必要があります。。
理由: 比較演算子の結果はブール型であるため、ブール型を比較す​​ることはできません。

package day999;
 
import java.util.Scanner;
 
public class ttt {
    
    
	public static void main(String[] args) {
    
    
/*
说明：
1. else 结构是可选的。
2. 针对于条件表达式：
   > 如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。
   > 如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
   > 如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
*/

		System.out.println("输入总原价");
		
		 //1，接受用户输入的原价
              double price = new Scanner(System.in).nextDouble();
             
              //2,计算折后价，并输出
              double now = price;//记录折后价
             //注意java中的多个条件不能写成如：a>b>c  而是要用逻辑运算符a>b&&b>c来输出。
              if( price >= 5000 ) {
    
    //满5000
                     now = price * 0.5 ;//now记录5折的价
              }else if( price >= 2000 ) {
    
    //满2000
                     now = price * 0.8 ;//now记录8折的价
              }else if( price >= 1000 ) {
    
    //满1000
                     now = price * 0.9 ;//now记录9折的价
              }
             
或者
if( price >= 1000 && price < 2000) {
    
    //满5000
                     now = price * 0.9 ;//now记录9折的价
              }else if( price >= 2000 && price < 5000 ) {
    
    //满2000
                     now = price * 0.8 ;//now记录8折的价
              }else if( price >= 5000  ) {
    
    //满1000
                     now = price * 0.5 ;//now记录5折的价
              }
 
              System.out.println("原价是："+price+"，折后价是："+now);
             
       }
      
}

2.4.4 演習 2: 統計学者のスコア

90点以上、優
80～89、良
70～79、平均
60～69、合格
60点以下、不合格

package game;
 
import java.util.Scanner;
 
public class aa {
    
    
	public static void main(String[] args) {
    
    
		double score = new Scanner(System.in).nextDouble();
         //!!!用来增强代码的健壮性
		if (score >= 100 || score <= 0) {
    
    
			System.out.println("请输入0~100以内的值");
            return;  //结束程序
		}
		if (score > 90 && score <= 100) {
    
    
			System.out.println("优秀");
		} else if (score >= 80 && score <= 90) {
    
    
			System.out.println("良好");
		} else if (score >= 70 && score <= 79) {
    
    
			System.out.println("中等");
		} else if (score >= 60 && score <= 69) {
    
    
			System.out.println("及格");
		}else if (score < 60) {
    
    
			System.out.println("不及格");
		}
 
	}
}
//优化
       String desc = "优秀";
      
       if(score >= 90) {
    
    //90分以上 优秀
           desc = "优秀";
       }else if(score >= 80 && score < 90 ) {
    
    //80~89 良好
           desc = "良好";
       }else if(score >= 70 && score < 80 ) {
    
    //70~79 中等
           desc = "中等";
       }else if(score >= 60 && score < 70 ) {
    
    //60~69 及格
           desc = "及格";
       }else if(score < 60) {
    
    //60分以下 不及格
           desc = "不及格";
       }
      
       System.out.println("得分是："+score+",属于："+desc);

2.4.5 演習 3: if を使用して 3 つの数値を比較する

/*
编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
对它们进行排序(使用 if-else if-else),并且从小到大输出。

说明：
1. if-else结构是可以相互嵌套的。
2. 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。
*/
import java.util.Scanner;
class IfTest2 {
    
    
	public static void main(String[] args) {
    
    
		
		Scanner scanner = new Scanner(System.in);

		System.out.println("请输入第一个整数：");
		int num1 = scanner.nextInt();
		System.out.println("请输入第二个整数：");
		int num2 = scanner.nextInt();
		System.out.println("请输入第三个整数：");
		int num3 = scanner.nextInt();

		if(num1 >= num2){
    
    
			if(num3 >= num1)
				System.out.println(num2 + "," + num1 + "," + num3);
			else if(num3 <= num2)
				System.out.println(num3 + "," + num2 + "," + num1);
			else
				System.out.println(num2 + "," + num3 + "," + num1);
			
		
		}else{
    
    
			if(num3 >= num2)
				System.out.println(num1 + "," + num2 + "," + num3);
			else if(num3 <= num1)
				System.out.println(num3 + "," + num1 + "," + num2);
			else
				System.out.println(num1 + "," + num3 + "," + num2);
			
		}

	}
}

2.5 【理解】分岐構造2：スイッチ

2.5.1 概要

ケースが確立されると、デフォルトを含む、この一致したケースのすべてのケースが、プログラムが終了するかプログラムの中断に遭遇するまで逆方向に突き進みます。
長所: 高効率、構造が明確
短所: 整数と等価にのみ適用可能

2.5.2 フォーム

switch(expr1) では、expr1 は整数式です。整数式はint 基本型または整数パッケージ化型にすることができます。byte 、short、char は暗黙的に int に変換できるため、これらもサポートされています。
注:

1. case ラベルは文字列定数またはリテラルである必要があり、スコープを宣言することはできません。
2. これは条件式ではなく式であることに注意してください(条件式: 結果はブール値です)。
3. スイッチ構造内の式は、次の 6 つのデータ型のうちの 1 つだけです:
   byte、short、char、int、列挙型 (JDK5.0 の新機能)、String 型 (JDK7.0 の新機能)
4. Break は switch-case 構造内で使用でき、このキーワードが実行されると switch-case 構造が飛び出すことを示します。
5. Break キーワードはオプションです。
6. デフォルト: if-else 構造体の else に相当します。
   デフォルト構造はオプションであり、位置は柔軟です。最後に記述する場合、ブレークを追加する必要はありません。

switch(变量或者表达式){
    
    
	case 1: 
	      break;
	case 2: 
	      break;    //break:  跳出switch循环,可选。
	case 3:
	      break; 
    case 4:
         break; 
	default:   //default 加个保险也可以不写,当前面都没有匹配到的时候相当于加个保险走默认的。
 
}

2.5.3 演習 1: 番号照合

package cn.tedu.ifdemo;
 
//测试switch语法
public class Test7_Switch {
    
    
    public static void main(String[] args) {
    
    
      测试1：
       int i = 2;
      
//  i 的类型 也就是括号里表示的类型 -- byte short int char jdk1.7新增了String
       switch( i ) {
    
    
       case 1 : 
            System.out.println(1);
            break;
       case '1' : 
            System.out.println('1');
            break;
      
       /*1,   当匹配到case时，程序会继续向后穿透所有case包括default，即
       *满足一个case条件时会把剩余所有case包括default里面的内容都会
       *进行输出，直到程序结束或者遇到break程序才结束。
       */
       case 2 : 
            System.out.println(2);
            break;
       //2,   break用来结束程序
       case 3 : 
            System.out.println(3);
            break;
       case 4 : 
            System.out.println(4);
            break;
       case 5 : 
            System.out.println(5);
            break;
       case 6 : 
            System.out.println(6);
            break;
      
       default: 
            System.out.println(0);//default之后不需要再写break
      
       }
	//如果输出的条件一样则可以简写为如：
         case 0:
		 case 1:
		 case 2:
		 case 3:
			 System.out.println("小明");
		     break;

	测试2：
      String season = "summer";
		switch (season) {
    
    
		case "spring":
			System.out.println("春暖花开");
			break;
		case "summer":
			System.out.println("夏日炎炎");
			break;
		case "autumn":
			System.out.println("秋高气爽");
			break;
		case "winter":
			System.out.println("冬雪皑皑");
			break;
		default:
			System.out.println("季节输入有误");
			break;
		}


		测试3：
		//**************如下的两种情况都编译不通过*********************
		//情况一：表达式为布尔类型
		/*
		boolean isHandsome = true;
		switch(isHandsome){
		
		case true:
			System.out.println("我好帅啊~~~");
			break;
		case false:
			System.out.println("我好丑啊~~~");
			break;
		default:
			System.out.println("输入有误~~~");
		}
		*/
		//情况二：case值不是常量
		/*
		int age = 10;
		switch(age){
		case age > 18:
			System.out.println("成年了");
			break;
		default:
			System.out.println("未成年");
		}
		*/
      
    }
   
}

2.5.4 演習 2: ケースの省略形

/*
例题：对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

说明：如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。
*/
class SwitchCaseTest1 {
    
    
	public static void main(String[] args) {
    
    
		
		/*
		int score = 78;
		switch(score){
		case 0:

		case 1:

		case 2:

			...
		case 100:
		
		}
		*/

		/*
		int score = 78;
		if(score >= 60){
		
		}else{
		
		}
		*/
		
		int score = 78;
		switch(score / 10){
    
    
		case 0:
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
			System.out.println("不及格");
			break;
		case 6:
		case 7:
		case 8:
		case 9:
		case 10:
			System.out.println("及格");
			break;

		}
		
		//更优的解决方案：
		switch(score / 60){
    
    
		case 0:
			System.out.println("不及格");
			break;
		case 1:
			System.out.println("及格");
			break;
		}
	
	}
}

2.6 if と switch の比較

/*
从键盘分别输入年、月、日，判断这一天是当年的第几天
 
   注：判断一年是否是闰年的标准：
       1）可以被4整除，但不可被100整除
	或
       2）可以被400整除


说明：
1. 凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立。
2. 我们写分支结构时，当发现既可以使用switch-case,（同时，switch中表达式的取值情况不太多），
  又可以使用if-else时，我们优先选择使用switch-case。原因：switch-case执行效率稍高。

*/
import java.util.Scanner;
class SwitchCaseExer {
    
    
	public static void main(String[] args) {
    
    
		
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入year：");
		int year = scan.nextInt();
		System.out.println("请输入month：");
		int month = scan.nextInt();
		System.out.println("请输入day：");
		int day = scan.nextInt();


		//定义一个变量来保存总天数
		int sumDays = 0;

		switch(month){
    
    
		case 12:
			sumDays += 30;
		case 11:
			sumDays += 31;
		case 10:
			sumDays += 30;
		case 9:
			sumDays += 31;
		case 8:
			sumDays += 31;
		case 7:
			sumDays += 30;
		case 6:
			sumDays += 31;
		case 5:
			sumDays += 30;
		case 4:
			sumDays += 31;
		case 3:
			//sumDays += 28;
			//判断year是否是闰年
			if((year % 4 == 0 && year % 100 != 0 ) || year % 400 == 0){
    
    
				sumDays += 29;
			}else{
    
    
				sumDays += 28;
			}

		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}

		System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天");
	}
}

3 Day04 – ループ

3.1 ループ構造1:for

3.1.1 概要

ループ構造とは、プログラム内で特定の機能を繰り返し実行するように設定されたプログラム構造を指します。ループ本体内の条件に基づいて、特定の関数の実行を継続するかループを終了するかを決定します。ループ構造は、判定条件に応じて、先に判定してから実行するループ構造と、先に実行してから判定するループ構造に分けることができる。。

for ループの利点: for ループ ステートメントは、反復をサポートする一般的な構造です。最も効率的で柔軟なサイクル構造。

循環の三要素：

1. ループ変数の初期化
2. ループの条件はブール型です (ループ変数に基づく)。
3. ループ変数の変更 (ループの終わりに向けて)

ループ変数: ループ内で繰り返し変化する数値。

3.1.2 フォーム

for(开始条件；循环条件；更改条件){
    
    
	循环体代码…
}
 
For循环的特殊用法：
1. 死循环
  For(;  ;){
    
      //死循环
}
2. 可以拆开写
 int i=1; 
 for(;i<10;i++){
    
     //向上拆
 }
 
for(int i=1;i<10;){
    
      //向下拆
     i++;   //注意这个地方多了个分号（;）}
3. 可以同时声明2个数：
  for(int i=1,j=6;i<6;i+2,j--){
    
    
 }   //for中表达式一和表达式三可以使用逗号，而表达式二多个只能使用 &&, || ,！(且,或,非)

3.1.3 演習 1: 0 ～ 10 を出力する

package cn.tedu.fordemo;
 
//测试for循环
public class Test8_For {
    
    
    public static void main(String[] args) {
    
    
       //for( 开始条件    ;   判断条件    ;  更改条件   ){   循环体   }
//     打印0到10
      
       //i用来记录每次获取到的值，默认是从0开始
       //i定义在for循环里面:在for循环内有效。出了for循环就失效了。
       for( int i = 0 ; i <= 10 ;  i++){
    
     
          
           System.out.println(i);  
       }
      
      
      
    }
}

3.1.4 演習 2: 10 から 0 を出力する

//从10开始，只要>=0，就打印，打印的数据依次递减
for( int i = 10 ; i >= 0 ; i-- ){
    
     
          
    System.out.println(i);
}

3.1.5 演習 3: 8,88,888,8888 を出力する

for( int i = 8 ; i <= 8888 ; i=i*10+8 ){
    
      
   
	System.out.print(i+",");//同行展示数据。如8,88,....
}

3.1.6 演習 4: [1,100] 内の奇数の数と偶数の数を求めます。

int count = 0 の場合、int count の代わりに追加の値 0 を割り当ててみませんか? ? day03が異常だった時に話しました。。

       int count = 0;//定义变量，记录奇数的个数
       int oucount = 0;//定义变量，记录偶数的个数,(定义为0，下面赋值不会影响程序)
       for(int i = 1 ; i <= 100 ; i++) {
    
    
           //判断，如果是奇数
           if( i % 2 == 1 ) {
    
       //也可以写！=0
              count++;//每次遇到一个奇数就+1
           }
           //判断，如果是偶数
           if( i % 2 == 0 ) {
    
    
              oucount++;//每次遇到一个偶数就+1
           }
       }
      
       System.out.println("奇数的个数是："+count+",偶数的个数是："+oucount);

3.1.7 演習 5: [1,100] の偶数と奇数の合計を求めます。

       int sum = 0;//定义变量，记录偶数和
       int jisum = 0;//定义变量，记录奇数和
       
       for(int i = 1 ; i <= 100 ; i++) {
    
    
           //判断，如果是偶数
           if(i % 2 == 0) {
    
    
              //对获取到的每个偶数求和
              sum = sum + i;
           }
          
           //判断，如果是奇数
           if(i % 2 == 1) {
    
     //或则i%2!=0也行
              jisum = jisum + i;//把每个奇数求和
           }
          
          
       }
      
       System.out.println("偶数和是："+sum+",奇数和是："+jisum);

3.2 ネストされた for ループ

3.2.1 概要

外層の状況に応じて内層が実行可能かどうかを判定し、実行可能であれば内層のコードをループし、外層を実行して判定を継続します。。

3.2.2 フォーム

for(…){
    
    
	for(…){
    
    
		
	}
}

3.2.3 入門ケース

package day0000;
/*
嵌套循环的使用
1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环

2.
外层循环：循环结构B
内层循环：循环结构A

3. 说明
① 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次

4. 技巧：
   外层循环控制行数，内层循环控制每行的列数
*/ 
public class T {
    
    
 
	public static void main(String[] args) {
    
    
//		f1();
		f2();
	}
 
	//总结1：当i=1时，j取到了所有满足条件的数据，1,2,3,4,5。
	//也就是说外循环执行1次，内循环执行多次
	private static void f1() {
    
    
		for(int i=1;i<=3;i++){
    
    //外循环
			System.out.println("i="+i);//1,2,3
			for(int j=1;j<=5;j++){
    
    //内循环
				System.out.println("j="+j);//1,2,3,4,5
			}
		}
	}
 
//总结2：外循环控制行，内循环控制列
	private static void f2() {
    
    
		for(int i=1;i<=3;i++){
    
    
			for(int j=1;j<=5;j++){
    
    
				System.out.print("*");
			}
			System.out.println();
		}
	}
 
}

3.2.4 演習 1: 正方形を印刷する

****
****
****
****
for(int i=1;i<5;i++){
    
    
	for(int j=1;j<5;j++){
    
    
		System.out.print("*");
	}
	System.out.println();
}	

3.2.5 演習 2: 左右の三角形を出力する

*
**
***
****
*****
//正直角三角形
private static void f4() {
    
    
	for (int i = 0; i < 5; i++) {
    
    //外循环，控制行，是一定的
		for (int j = 0; j <= i; j++) {
    
    //内循环，列是不固定的，是递增的
			System.out.print("*");//保证第一行打印出来一个*，注意条件
		}
		System.out.println();
	}
}

3.2.6 演習 3: 99 の九九を印刷する

//99乘法表   正序
1*1=1 
2*1=2 2*2=4 
3*1=3 3*2=6 3*3=9 
4*1=4 4*2=8 4*3=12 4*4=16 
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
private static void f4() {
    
    
	for (int i = 1; i < 9; i++) {
    
    //外循环，控制行，是一定的
		for (int j = 1; j <= i; j++) {
    
    //内循环，列是不固定的，是递增的
			System.out.print(i+"*"+j+"="+i*j+" ");//保证第一行打印出来一个*，注意条件
		}
		System.out.println();
	}
}

//乘法表倒序
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*4=4	2*4=8	3*4=12	4*4=16	
1*3=3	2*3=6	3*3=9	
1*2=2	2*2=4	
1*1=1	

		for(int i=9;i>=1;i--) {
    
    
			for(int j=1;j<=i;j++) {
    
    
				System.out.print(j+"*"+i+"="+i*j+"\t");
			}
			System.out.println();
		}
 
 

3.2.7 演習 4: 直角三角形を出力する

直角に印刷

    *
   **
  ***
 ****
*****
 
package day999;
public class a {
    
    
    public static void main(String[] args) {
    
    
       //输出5行
       for(int i=1;i<=5;i++){
    
    
           //空格三角
           for(int x=5;x>i;x--){
    
    //还可以改为：for(int x=1;j<=5-i;x++) 
              System.out.print(" ");
           }
           //*号三角
           for(int j=1;j<=i;j++){
    
    
              System.out.print("*");
           }
           System.out.println();
       }
    }
}

3.2.8 演習 5: 完全な三角形を出力する

完全な三角形を印刷する

     *
    ***
   *****
  *******
 ********* 
package day999;
public class a {
    
    
    public static void main(String[] args) {
    
    
       //打印5行
       for(int i=1;i<=5;i++){
    
    
           //打印空格的倒三角(原理是：每轮输出一个空格)
           for(int j=5;j>=i;j--){
    
     //可换：for(int j=1;j<=5-i;j++)
              System.out.print(" ");
           }
          
           //打印*号的正三角
           for(int k=1;k<=i*2-1;k++){
    
    
              System.out.print("*");
           }
          
           System.out.println();
       }
    }
}
 

3.3 拡張された for ループ

package lianxi;

import java.util.Random;
import java.util.Scanner;

public class Ta {
    
    

	public static void main(String[] args) {
    
    
		
		
		int [] numbers = {
    
    10,20,50,7,0,9,22,11};//定义一个数组
		for (int aa: numbers) {
    
    
			System.out.println(aa);
		}

	}

}

3.4 休憩と継続

ループを終了するには、次の 2 つの方法を使用できます。

予防: Break、Continue を直接項目の後に宣言することはできません。宣言しないと、コンパイルまたはエラーが報告されます。以下に示すように:

3.4.1 フォーム

break: 中断当前循环，简单粗暴
for(){
    
    
	代码1
if(条件){
    
    
  代码3…
	break;//如果成立，直接跳出这个for循环
}
代码2…
}
continue：跳出本次循环，进入下一轮
for(){
    
    
	代码1
if(条件){
    
    
	代码3…
	continue;//如果成立，跳出本次for循环，进入下一轮
}
代码2…
}

3.4.2 演習 1: 数字 88 を見つけます

ユーザーが入力した 100 個の数字を受け取ります。88 でない場合は入力を続け、88 が見つかった場合は戻ります。

package cn.tedu.breakdemo;
 
import java.util.Scanner;
 
//测试break和continue
//总结：break和continue都可以结束循环。
//1，break可以立刻结束循环简单粗暴。continue是结束当前循环可以继续下一次循环。
//2，break和continue之后都不能出现代码，出现了也是不可到达的代码
public class Test3_Break {
    
    
       public static void main(String[] args) {
    
    
             
              for(int i = 1 ; i <= 100 ; i++) {
    
    
                    
                     //1，接受用户输入的数字
                     int input = new Scanner(System.in).nextInt();
                    
                     //2，判断是不是88
                     if(input == 88) {
    
    //是88
                           
                            System.out.println("中了");
                            break;//程序结束
        
                           
                     }else if(input != 88) {
    
    //不是88
                           
                            continue;//继续输入
                     }          
              }       
       }    
}

3.5 ループ構造 2: while

まず判断してから実行する

3.5.1 フォーマット

while(执行条件){
    
    
	代码…
}

3.5.2 演習 1: 1 ～ 100 の乱数を生成し、その数字を推測します。

乱数を生成し、ユーザーが入力した数値と比較します。
乱数を生成するには、API を参照して詳細を確認してください。

package cn.tedu.whiledemo;
 
import java.util.Random;
import java.util.Scanner;
/**
 *测试while循环
 *总结:
 * 1.while也是一种循环结构：while(循环条件){循环体}
 * 2.while(true)是简单的实现了死循环的形式，for也可以实现代码显得复杂一些。
 * 3.这种结构  --  先判断，再执行
 */
public class Test4_While {
    
    
       public static void main(String[] args) {
    
    
        /**
		 * 产生随机数的2种方法：
		 *  第1种：int num=(int)(Math.random()*1000+1);  生成随机数1～1000
		 *  解释：Math.random()返回的是0(包含)到1(不包含)之间的double值,转化为整数需要强转。
		 *  第2种：int random = new Random().nextInt(100) +1; 生成随机数1~100
		 *  解释：要产生m以内的随机数，默认从0开始 ，不包括m 如：0~100 不包括100(0~99)可以加个1变为（1~100）
		 */
		           
		         //1,让程序产生随机数
		         int random = new Random().nextInt(100) +1;
		         System.out.println(random);
		             
		         //2,开始猜 --重复做a b的事情，放入循环结构中
                 //while(random > 50) {
    
    
		             
		        //for形式的死循环:让循环条件一直为true就行 
                //for(int i = 1; i >= 1 ; i++ ) {
    
    
		         while(true) {
    
     //死循环  -- 必须设置程序的出口！！

		                //a,接受键盘输入的值
		                int input = new Scanner(System.in).nextInt();
		                    
		                //b,拿到输入的值，和 ，random去比
		                if(input > random) {
    
    
		                       System.out.println("大了");
		                }else if(input < random) {
    
    
		                       System.out.println("小了");
		                }else if(input == random) {
    
    
		                       System.out.println("中了");
		                       break;//程序结束  -- 死循环的出口！！！
		                }
		                    
		         }
             
             
       }
      
}
 

3.5.2 演習 2: 乱数 10 ～ 100 を生成する

//如何获取一个随机数：10 - 99
// [0.0,1.0) --> [0.0,90.0) --->[10.0, 100.0) -->[10,99]
/*解释：
Math.random()生成double类型的值：[0.0,1.0),包含0无限接近于1。
乘以90变为[0.0,90.0)，包含0无限接近于90。
加10变为[10.0, 100.0)，包含10无限接近于100(99.99999999...)。
在强转为int类型，舍弃掉小数位变成-->[10,99]
*/
int value = (int)(Math.random() * 90 + 10);
System.out.println(value);
//公式：[a,b]  :  (int)(Math.random() * (b - a + 1) )+ a

3.6 ループ構造 3: do-while

最初に実行し、後で判断する

3.6.1 フォーマット

do{
    
    
	代码…
}while(执行条件);    //注意这里有个分号

3.6.2 演習 1: 数字を推測する

乱数を生成し、ユーザーが入力した数値と比較します。

package cn.tedu.whiledemo;
 
import java.util.Random;
import java.util.Scanner;
 
//测试do...while循环
//总结：
//do...while  结构，保证循环体代码 ，最少，执行一次
//能不能继续循环，要看能不能满足循环条件
public class Test5_Dowhile {
    
    
    public static void main(String[] args) {
    
    
       int random = new Random().nextInt(100) + 1;
       System.out.println(random);
 
       do {
    
    
           // a,接受键盘输入的值
           int input = new Scanner(System.in).nextInt();
 
           // b,拿到输入的值，和 ，random去比
           if (input > random) {
    
    
              System.out.println("大了");
           } else if (input < random) {
    
    
              System.out.println("小了");
           } else if (input == random) {
    
    
              System.out.println("中了");
              break;// 程序结束 -- 死循环的出口！！！
           }
          
       }while (random > 50);//明确循环条件
 
    }
   
   
}

3.7 要約: 3 種類のサイクルの違い

3 種類のループはすべて相互に置き換えることができます。
1. for: ループ数を知る (適用率が最も高い)
2. while/do while: ループ数が不確実な場合
3. while: 準拠していない場合に最初に判断します。 4. do while:コードは少なくとも 1 回実行され
、ルールに従っていると判断され、コードが再度実行されます。

どのループを使用するかを決定するにはどうすればよいですか?
1. 回数に関する場合は for ループを使用します。
2. 条件 1 と条件 3 が同じかどうかを判定する場合、同じ場合は do while を使用し、異なる場合は while を使用します (変数の初期化) 、状態、変化量）

4 Day05 – メソッド + アレイ

4.1 方法

4.1.1 概要: メソッド (関数、プロシージャ)

1. 方法: 特定のビジネス ロジック関数をカプセル化します。
2. メソッドはできる限り独立している必要があり、各メソッドは 1 つのことだけを実行します。
3．メソッドは複数回呼び出すことができます。
4. コードの重複を減らすと、コードのメンテナンスとチームのコラボレーションに役立ちます。
5. メソッドにはパラメータを含めることも、パラメータを含めないこともできます。複数のパラメータはカンマで区切られます (要件に応じて)。
6. メソッドとメソッドは兄弟関係にあります。
7. メソッド名の命名規則: キャメルケースの命名方法。
8.メソッド内で他のメソッドを呼び出すことはできますが、メソッド内でメソッドを定義することはできません。

4.1.2 フォーム

修饰符  返回值类型  方法名(参数列表){
    
    
	方法体;
    return 返回值；// void(无返回值)   int,double,String…有返回值
}

4.1.3 演習 1: メソッドの呼び出し

メソッド呼び出し:メソッドのシグネチャに基づいて呼び出されます。

メソッドシグネチャ: メソッド名 + パラメータリスト

構文:

1. 戻り値なしの型 (空所) :方法名(有参传参);
2. 戻り値の型は次のとおりです。数据类型 变量 = 方法名(有参传参);

注:

1. 1 つのクラス内に、まったく同じシグネチャを持つ 2 つのメソッドが存在することはできません。
2. 戻り値の型が void でない限り、戻り値 return が存在する必要があり、それを受け取るデータ型を宣言する必要があります。
3. 実際のパラメータ: メソッド呼び出し時に渡されるパラメータ (明確な数値または不確実な数値の場合があります)
4. 仮パラメータ: メソッドを定義するとき、パラメータはメソッドのパラメータ リストで定義されます。
5. メソッドが呼び出されると、実際のパラメータ値がメソッドのパラメータ変数に渡されます。渡されるパラメータの型と数がメソッドの宣言に準拠していることを確認する必要があります。

説明:次の呼び出しはすべて同一个类メソッド間の呼び出しであり、静的メソッドは相互に呼び出すことができるため、メソッドを静的リソースとして変更する必要があります。。
静的リソース内で非静的リソースを呼び出したい場合は、オブジェクトを作成することで呼び出すことができます。

package cn.tedu.method;
//包名可以直接在代码上修改，鼠标放上去会提示创建没有的包。
//同理 ：类也一样
 
//测试方法的使用+-------------------------------
public class Test6_Method {
    
    
    public static void main(String[] args) {
    
    
       System.out.println(1);
      
       function();//调用了指定的function()
      
       System.out.println(2);
    }
   
    //创建function()  如果没有在main方法中调用方法，则程序不会主动执行这个方法。
    //修饰符  返回值  方法名(参数列表){方法体}
    public static void function() {
    
    
       System.out.println(3);
       System.out.println(4);
       System.out.println(5);
      
    }
   
   
}

通过创建对象可以在静态调用非静态：
package com.cn.ins;


//包名可以直接在代码上修改，鼠标放上去会提示创建没有的包。
//同理 ：类也一样

//测试方法的使用+-------------------------------
public class Test6_Method {
    
    
  public static void main(String[] args) {
    
    
     System.out.println(1);
    
    // function();//调用了指定的function()
    
     System.out.println(2);
     Test6_Method a=new Test6_Method();
     a.function();
     
  }
 
  //创建function()  如果没有在main方法中调用方法，则程序不会主动执行这个方法。
  //修饰符  返回值  方法名(参数列表){方法体}
  public  void function() {
    
    
     System.out.println(3);
     System.out.println(4);
     System.out.println(5);
    
  }
 
 
}

4.1.4 演習 2: パラメータを渡すメソッド

package cn.tedu.method;
 
//测试方法的使用
public class Test6_Method {
    
    
    public static void main(String[] args) {
    
    
       System.out.println(1);
      
//     function();//调用了指定的function()
      
//     param(10);//方法传参    
//     param2("jack",10);//传两参数--叫实参
//注意：调用方法时传的参数叫做实参，不管是数字还是一个变量都是实参
    
//     param3(5,10,"jack"); 参数的个数和类型相同，但是顺序不同也代表参数列表不同，方法不同。
       param4("jack",5,10);
      
       System.out.println(2);
       //在括号外面赋值，与方法内直接赋值一样。
       int m=10;
       String n=”rose”;
       Param5(m,n);
    }
    //创建param5的方法
    public static void param5(inta,String b) {
    
    
    System.out.println(a+b+);
}
 
    //TODO 创建param4("jack",5,10) --方法传参：参数类型必须匹配
    public static void param4(String a,int b,int c) {
    
    
       System.out.println(a+b+c);//jack510
    }
   
    //TODO 创建param3(5,10,"jack") --方法传参：参数类型必须匹配
//多个参数之间用”,”隔开。
    public static void param3(int a,int b,String c) {
    
    
       //+在数字间是加法运算，和字符串+是拼接字符串
       System.out.println(a+b+c);//15jack
    }
   
    //创建param2("jack",10) --方法传参：参数类型必须匹配
    //String n,int a  -- 叫形参：方法里面的参数叫形参
    public static void param2(String n,int a) {
    
    
       System.out.println(n);
       System.out.println(a);
    }
   
   
    //创建param() --方法传参：参数类型必须匹配
    //修饰符  返回值  方法名(参数列表){方法体}
//  public static void param(参数类型  参数名) {
    
    
    public static void param(int num) {
    
    
       System.out.println(num);
    }
   
    //创建function()
    //修饰符  返回值  方法名(参数列表){方法体}
    public static void function() {
    
    
       System.out.println(3);
       System.out.println(4);
       System.out.println(5);
      
    }
   
}

4.1.5 演習 3: メソッドの戻り値

return 返回值；:メソッドが終了すると、戻り値と呼ばれるデータを返すことができますが、メソッドは宣言時に戻り値の型を指定する必要があります。

注:

1. メソッドには戻り値がある場合もあれば、戻り値がない (void) 場合もあります。
2. return direct 項目の後に、break や continue のような実行ステートメントを宣言しないでください。宣言しないと、コンパイルでエラーが報告されます。
   

戻り値が返されるのはいつですか? 戻り値がない場合はどのような場合ですか?
メソッドの実行が終了すると:

1. メソッド内で特定のデータを使用する必要がある場合は、戻り値があります(戻り値の型を void にすることはできません。戻り値は return と組み合わせて使用​​されます。戻り値がある場合は、変数を定義するか、またはそれを受け入れる配列。)
2. メソッド内で特定のデータを使用する必要がなくなった場合、戻り値はありません(戻り値の型が void であるため、return を記述する必要はありません)。

Return の 2 つの形式の機能は何ですか?
最初の方法: return 值 ；
1. メソッドの実行を終了します。
2. 呼び出し元に戻ります。(注: 戻り値の型がある限り、戻り値が存在する必要があります)

2 番目のタイプ: return ;
3. メソッドの実行を終了します (注: 戻り値のないタイプに対して return を記述する必要はありません。プログラムは実行後に終了し、直接記述するのは意味がないからです。 if 分岐構造と組み合わせて使用​​して、プログラムから飛び出すことができます。)

package cn.tedu.method;
                           
//测试方法返回值
public class Test7_Method2 {
    
    
    public static void main(String[] args) {
    
    
      
       //result记录着method()的执行结果a b的和
       int result = method(10,5);
       System.out.println(result);
      
       //TODO 
       String name = method2("jack","rose","jerry");
       System.out.println(name);
      
    }
   
    //TODO 创建 method2("jack","rose","jerry")
    public static String method2(String a,String b,String c){
    
    
      
       return a+b+c;//返回值不单单是一个变量，数。也可以返回一个式子
    }
   
   
    //创建method(10,5)
    //注意：方法的返回值要和result变量的类型一致
    public static int method(int a,int b) {
    
    
      
       //通过 return 可以把方法执行的结果，返回给，调用位置！！
       return a+b;
    }
   
   
   
}
//注意：例子，返回的是不同类型看是否是字符串拼接，用String
String sum2=method("jack",10,5);
		System.out.println(sum2);
	public static String method(String c,int a,int b) {
    
    
		return c+a+b; //这里是一个字符串的拼接所以用String类型。返回值类型与return后的类型一致。
	}

4.2 メソッドのオーバーロード

4.2.1 コンセプト

1. メソッドのオーバーロードとは、同じクラスに、メソッド名は同じ、パラメータリストは異なります、メソッド本体は通常異なり、同じには意味がありません。オーバーロードはメソッド本体とは何の関係もありません。
2. コンパイラは、コンパイル中にメソッドのシグネチャに従って自動的にさまざまなメソッドをバインドし、呼び出します。(オーバーロードされたメソッドは完全に異なるメソッドと考えることができますが、メソッド名が同じであるだけです。
3.オーバーロードはメソッドに対するものです。

注:メソッドのオーバーロードの決定は、メソッドの権限修飾子、戻り値の型、仮パラメーター変数名、またはメソッド本体とは何の関係もありません。

オーバーロードの意味: プログラマにとって、覚えておく必要があるメソッド名は非常に単純で、名前付きのメソッドを覚えるだけでよく、メソッドのパラメータは非常に柔軟に渡すことができます。

パラメータのリストは異なります: パラメータのタイプ、順序、数が含まれます。

4.2.2 演習 1: 数値の合計

package cn.tedu.overload;
 
//测试方法重载：
//要求：方法名相同+参数列表不同
 
//意义：由于用户在使用时，传入的参数我们不知道，为了体现我的程序非常的灵活
//尽量多提供一些参数不同，名字相同的方法
public class Test8_Overload {
    
    
   
    public static void main(String[] args) {
    
    
       add(5);
       add(10,5);
       add("jack",5);
       add(10,"rose");
 
 
    //TODO
       print(10);
       print("jerry");
       print('中');
    }
   
    //创建add(10,"rose")
    public static void add(int a,String b) {
    
    
       System.out.println(a+b);//10rose
    }
   
    //创建add("jack",5)
    public static void add(String a,int b) {
    
    
       System.out.println(a+b);//jack5
    }
   
    //创建add(10,5)
    public static void add(int a,int b) {
    
    
       System.out.println(a+b);
    }
   
    //创建add(5)
    public static void add(int a) {
    
    
       System.out.println(a*a);
    }
   
}
//总结：方法，传参，数据类型与参数列表保持一致，（即：个数，类型，顺序保持一致)。
//返回值：若有返回值应与返回值类型，返回值接收的类型保持一致。
 
//如：
public static void main(String[] args) {
    
    
		//方法练习
		method(2,3,"小明");
		String aa=method2(2,3,"小红");
		System.out.println(aa);
 
	}
	public static void method(int a,int b,String c) {
    
    
		System.out.println(a+b+c);
	}
	public static String method2(int a,int b,String c) {
    
    
		return a+b+c;//有String类型，int 类型。它拼接的是字符串类型，所以应该用String作为它的返回值类型，它的接受值也是String类型。
	}

4.2.3 演習 2: データの印刷

package day004;                          
                                            
public class Test07 {
    
                        
                                           
	public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
		print(10);                         
		print(2.2);                           
		print(true);                  
		print("jack");                          
                                                   
	}                                       
	public static void print(int a) {
    
    
		System.out.println(a);               
	}                                      
	public static void print(double a) {
    
    
		System.out.println(a);               
	}                                            
	public static void print(boolean a) {
    
    
		System.out.println(a);               
	}                                         
	public static void print(String name) {
    
    
		System.out.println(name);             
	}                                            
                                               
}                     

4.2.4 演習 3: オーバーロードに対する自動型昇格

メソッドをオーバーロードする場合、メソッド呼び出し時に入力した実パラメータに対応するメソッドがなく、自動型変換が成立した場合は、条件を満たすラージ型のメソッドが呼び出されます。

package com.cn.ca;

public class StudentTest {
    
    

	public static void main(String[] args) {
    
    
		Teacher teacher = new Teacher();
		/*解释：自动类型提升
		 * getSum方法没有注释之前根据方法的调用规则，调用getSum(int i,int j)输出为1
		 * getSum方法没有注释之后虽然调用时输入的值为int类型，但会自动类型提升，调用getSum(double d1,double d2)输出为2
		 */
		teacher.getSum(1, 5); 

	}

}

class Teacher{
    
    
	
//	public void getSum(int i,int j){
    
    
//		System.out.println("1");
//	}
	
	public void getSum(double d1,double d2){
    
    
		System.out.println("2");
	}
	
}

4.3 可変パラメータ

可変引数は本質的には配列です。

package com.cn.ca;


/*
 * 可变个数形参的方法
 * 
 * 1.jdk 5.0新增的内容
 * 2.具体使用：
 *   2.1 可变个数形参的格式：数据类型 ... 变量名
 *   2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
 *   2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
 *   2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
 *   2.5 可变个数形参在方法的形参中，必须声明在末尾
 * 	 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。
 *   2.7 同一类型普通方式优先级比可变参数更高
 *   2.8 遍历方式和数组相同
 *   
 * 
 */
public class MethodArgsTest {
    
    
	
	public static void main(String[] args) {
    
    
		
		MethodArgsTest test = new MethodArgsTest();
		test.show(12);
//		test.show("hello");
//		test.show("hello","world");
//		test.show();
		
		
		//调用方法形参是数组相比是可变参数更麻烦些，当然这个数组的调用方式也可以调用可变参数
		test.show(new String[]{
    
    "AA","BB","CC"});
		
	}
	
	
	public void show(int i){
    
    
		
	}
	
	public void show(String s){
    
    //同一类型普通方式优先级比可变参数更高
		System.out.println("show(String)");
	}
	
	public void show(String ... strs){
    
    //调用时输入的参数可以是0个，可以是多个
		System.out.println("show(String ... strs)");
		
		for(int i = 0;i < strs.length;i++){
    
    //遍历方式和数组相同
			System.out.println(strs[i]);
		}
	}
	/*不能与上一个方法同时存在String[] strs和String ... strs，
	  编译器认为方法名相同 参数列表相同的数组和可变参数是同一个方法，不能共存。 
	*/
//	public void show(String[] strs){
    
    
//		
//	}
	
	//The variable argument type String of the method 
	//show must be the last parameter
//	public void show(String ...strs,int i){ 多个参数，可变参数只能声明在最后
//		
//	}
	
}

4.4 メソッドの値の転送

4.4.1 復習: 変数代入操作

package com.cn.ca;


/*
 * 
 * 关于变量的赋值：
 * 
 *  如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
 *  如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
 * 
 */
public class ValueTransferTest {
    
    
	
	public static void main(String[] args) {
    
    
		
		System.out.println("***********基本数据类型：****************");
		int m = 10;
		int n = m;
		
		System.out.println("m = " + m + ", n = " + n);//m = 10, n = 10
		
		n = 20;
		
		System.out.println("m = " + m + ", n = " + n);//m = 10, n = 20
		
		System.out.println("***********引用数据类型：****************");
		
		Order o1 = new Order();
		o1.orderId = 1001;
		
		Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
		
		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);//o1.orderId = 1001,o2.orderId = 1001
		
		o2.orderId = 1002;//改变了o2的值 o1也随之改变
		
		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);//o1.orderId = 1002,o2.orderId = 1002
		
	}
	
}

class Order{
    
    
	
	int orderId;
	
}

4.4.2 同様: メソッドの仮パラメータ代入操作 - 基本データ型

package com.cn.ca;
/*
 * 方法的形参的传递机制：值传递
 * 
 * 1.形参：方法定义时，声明的小括号内的参数
 *   实参：方法调用时，实际传递给形参的数据
 * 
 * 2.值传递机制：
 * 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
 * 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
 * 
 */
public class ValueTransferTest1 {
    
    
	public static void main(String[] args) {
    
    
		
		int m = 10;
		int n = 20;
		
		System.out.println("m = " + m + ", n = " + n);//m = 10, n = 20
		//交换两个变量的值的操作
//		int temp = m ;
//		m = n;
//		n = temp;
		
		ValueTransferTest1 test = new ValueTransferTest1();
		test.swap(m, n);
		
		System.out.println("m = " + m + ", n = " + n);//m = 10, n = 20 此时仍输出的是main中的m n而不是swap方法中的m n
		
		
	}
	
	
	public void swap(int m,int n){
    
    //相当于是把10 20赋值给了新的变量m n,形参是局部变量出了方法就失效
		                          //如果复制的是引用地址，堆的数据只有一份可以交换成功，出了方法也不会失效
		int temp = m ;
		m = n;
		n = temp;
		System.out.println("m = " + m + ", n = " + n);//m = 20, n = 10
	}
}

4.4.3 同様: メソッドパラメータ割り当て操作 - 参照データ型

package com.cn.ca;


public class ValueTransferTest2 {
    
    
	
	public static void main(String[] args) {
    
    
		
		Data data = new Data();
		
		data.m = 10;
		data.n = 20;
		
		System.out.println("m = " + data.m + ", n = " + data.n);//m = 10, n = 20
		
		//交换m和n的值
//		int temp = data.m;
//		data.m = data.n;
//		data.n = temp;
		
		ValueTransferTest2 test = new ValueTransferTest2();
		test.swap(data);
		
		
		System.out.println("m = " + data.m + ", n = " + data.n);//m = 20, n = 10交换成功
		
	}
	
	public void swap(Data data){
    
    
		int temp = data.m;
		data.m = data.n;
		data.n = temp;
	}
	
}

class Data{
    
    
	
	int m;
	int n;
	
}

4.5 再帰

注:

1. 再帰レベルが多すぎてはいけません。多すぎると、コンピュータの効率が大幅に低下します。
2. 再帰が必要ない場合は、再帰を必要とせず、他のアルゴリズムで実現できます。

4.5.1 再帰的なケースの演習

package com.atguigu.java2;

/*
 * 递归方法的使用（了解）
 * 1. 递归方法：一个方法体内调用它自身。
 * 2. 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无需循环控制。
 * 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
 * 
 */
public class RecursionTest {
    
    

	public static void main(String[] args) {
    
    

		// 例1：计算1-100之间所有自然数的和
		// 方式一：for循环
		int sum = 0;
		for (int i = 1; i <= 100; i++) {
    
    
			sum += i;
		}
		System.out.println(sum);
		// 方式二：递归
		RecursionTest test = new RecursionTest();
		int sum1 = test.getSum(100);
		System.out.println(sum1);
		
		System.out.println("*****************");
		int value = test.f(10);
		System.out.println(value);

	}

	// 例1：计算1-n之间所有自然数的和
	public int getSum(int n) {
    
    // 3

		if (n == 1) {
    
    
			return 1;
		} else {
    
    
			return n + getSum(n - 1);
		}

	}

	// 例2：计算1-n之间所有自然数的乘积:n! 阶乘如5*4*3*2*1
	public int getSum1(int n) {
    
    

		if (n == 1) {
    
    
			return 1;
		} else {
    
    
			return n * getSum1(n - 1);
		}

	}
	
	//例3：已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
	//其中n是大于0的整数，求f(10)的值。
	public int f(int n){
    
    
		if(n == 0){
    
    
			return 1;
		}else if(n == 1){
    
    
			return 4;
		}else{
    
    
//			return f(n + 2) - 2 * f(n + 1);
			return 2*f(n - 1) + f(n - 2);
		}
	}

	//例4：斐波那契数列
	
	//例5：汉诺塔问题
	
	//例6：快排

}

4.6 配列

4.6.1 アレイの概要と分類

概要: 配列とは、同じ種類の複数のデータを一定の順序で並べ、名前を付け、番号を付けることで一元管理したものです。

配列の分類:

• ① 次元による：1次元配列、2次元配列、…
• ②配列要素の種類に応じて、基本データ型要素の配列、参照データ型要素の配列

4.6.2 配列関連の概念

配列 Array の記号は[ ]です。

配列内の要素の値を取得する: 要素の添字から取得できます。添字は 0 から始まり、添字の最大値は長さ -1 です。

添え字:添え字およびインデックスとも呼ばれます

配列の長さ: 要素数

配列の型: Array 配列は参照型です。住所が保存されている、アドレスは空間内でほとんどメモリを占有しません (単なる数字の文字列)。配列の要素は、基本データ型または参照データ型のいずれかになります。

4.6.3 配列の特性

1. 配列は順序付けされます。
2. 配列オブジェクトを作成すると、メモリ内に連続した領域が開きます。
3. 配列の長さは決定されており、作成後に変更することはできません。
4. 配列内の要素は同じ型であり、型の混合は許可されません。
5. 配列は参照データ型の変数です。配列の要素は、基本データ型または参照データ型のいずれかになります。
6. 配列変数は参照型です。配列はオブジェクトとみなすこともできます。配列内の各要素はオブジェクトのメンバー変数に相当します。
   配列自体はオブジェクトです。Java では、オブジェクトはヒープ内にあります。したがって、配列配列がプリミティブ型を格納するか、他のオブジェクト型を格納するかに関係なく、配列オブジェクト自体はヒープ内にあります。

4.6.4 1次元配列の宣言

一般に、動的初期化と静的初期化に分けられます。

構文:

数组类型[ ]  数组名 = 数组对象；//推荐使用
   或者
数组类型  数组名[ ] = 数组对象；//不推荐使用，这是c++语言的习惯，早期为了c++的程序员学习java创建的。

ケース:

动态初始化：先声明后赋值，需要指定存入的元素个数。
int[] a = new int[4];//数组的类型应该与所存入的每一个数据类型一致
a[0] =1;
a[1] =4;
a[2] =7;
a[3] =5;

静态初始化:声明数组的同时赋值
int[] b = new int[]{
    
    1,2,3,4,5};//数组之间的元素用逗号隔开。
int[] c = {
    
    1,2,3,4,5};//简写形式

配列のデフォルトの初期化: 配列は参照型であり、その要素はクラスのインスタンス化変数と同等であるため、配列にはスペースが割り当てられています, ここで、各要素もインスタンス変数と同じ方法で暗黙的に初期化されます。

int[] aa = new int[5];
此时已经在内存中分配好空间了，每个元素的默认值都为int类型的值 0.

4.6.5 配列の長さ

• 長さプロパティは配列の長さを取得します。
• 配列が作成されると、その長さは不変になります。つまり、配列は固定長になります。
• 長さ 0 の配列が許可されます。

4.6.6 配列の境界

4.6.7 演習 1: hello を配列に格納する

package cn.tedu.array;
 
import java.util.Scanner;
 
//这个类用来测试数组的创建
public class Test1_Array {
    
    
       public static void main(String[] args) {
    
    
              //1，创建数组。存入hello
              //确定数组类型，数组长度 
//           静态
//因为每个格子放一个字符，所以用char类型。
              char[] a = new char[] {
    
    'h','e','l','l','o'};
              char[] b =  {
    
    'h','e','l','l','o'};
              System.out.println(a);
              System.out.println(b);
             
              // 2，动态 创建数组，需要，指定数组的长度！！
              char[] c = new char[5];
             //注意：存字符串是用的char 数组。不是string
 
              //3，数组中的元素都有下标，默认从0开始
              c[0]='h';//给第1个元素，也就是下标为0的元素，赋值
              c[1]='e';//给第2个元素，也就是下标为1的元素，赋值
              c[2]='l';//给第3个元素，也就是下标为2的元素，赋值
              c[3]='l';//给第4个元素，也就是下标为3的元素，赋值
              c[4]='o';//给第5个元素，也就是下标为4的元素，赋值
             
              //4，java.lang.ArrayIndexOutOfBoundsException数组下标越界异常
             //原因是数组的长度如果是5，最大下标是4，根本不存在下标为5的情况，下标5超出范围
             //c[5]='o';//给第6个元素，也就是下标为5的元素，赋值  ---  报错！！
             
              System.out.println(c);
              
       }
      
}

4.7 配列の走査

配列の位置に最初から最後まで順番にアクセスします。

4.7.1 フォーム

1.普通for循环
for(从下标为0的位置开始；到数组长度-1结束；下标++){
    
    
    循环体代码
}
2.增强for循环，但是取不到下标。
for(声明语句：表达式){
    
    
    循环体代码
} 

4.7.2 演習 1: for ループトラバーサルの拡張

package lianxi;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class Ta {
    
    

	public static void main(String[] args) {
    
    
		int[] arrays = {
    
    1,3,6,3,8,9,0};
		for(int aa:arrays) {
    
    
			System.out.println(aa);
		}
	}
	
}

4.7.3 演習 2: 各月の日数を出力する

package cn.tedu.array;
 
//数组练习
public class Test2_Array2 {
    
    
    public static void main(String[] args) {
    
    
      
       method();// 输出每个月的天数
    }
 
    // 创建method()
    public static void method() {
    
    
       // 1，静态创建数组
       int[] days = {
    
     31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 
       // 2，用下标遍历数组
       // i代表了下标
       // int i = 0 ，从下标 0开始
       // i <= days.length-1，到下标的最大值结束
       // i++，依次向后遍历
       for (int i = 0; i <= days.length - 1; i++) {
    
    
           // days[i] 指days数组中，每个下标存着的值
           System.out.println((i + 1) + "月有" + days[i] + "天");
       }
    }
 
}//直接输出数组则输出的是地址，输出对应的下标才是它代表的元素

配列内の各添字で表される要素を順番に出力します。

4.7.4 演習 3: 配列を走査して 1 ～ 10 を格納する

package lianxi;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class Ta {
    
    

	public static void main(String[] args) {
    
    
		
		  //1，动态 创建数组
        int[] a = new int[10];
        System.out.println(Arrays.toString(a));//[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
       
        //2，遍历数组，存数据
        for(int i = 0 ; i <= a.length-1 ; i++ ) {
    
    
               //获取每个元素a[i]
               a[i] = i+1;
        }
       
        //3,查看数组中的元素  
        System.out.println(a);//[I@659e0bfd]
        /**
         * 除了char数组可以直接输出里面的元素，其它的数组都是地址.
         * 想看不是char[]的数组里的元素是啥--Arrays工具类  toString()可以将指定的数组数据显示成一个字符串
         */
        System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
	
	}
	
}

配列を直接出力します。

4.7.5 演習 4: ランダム配列の作成

100以内のランダムな値の配列を取得：新しいRandom()メソッド

// 创建method3()
    public static void method3() {
    
    
       //1，  动态 创建数组
       int a[] = new int[10];
      
       //2.   遍历数组，重新赋值
       for(int i = 0 ; i <= a.length-1 ; i++) {
    
    
           //a[i]获取元素
           a[i]=new Random().nextInt(100);
       }
      
       //3.   查看数组里的元素
       System.out.println(Arrays.toString(a));
      
    }

4.7.6 演習 5: ランダム配列を作成して最大平均と最小平均を見つける

[10,99] 内のランダムな値の配列を取得: new Random() メソッド

package com.atguigu.java;
/*
 * 算法的考查：求数值型数组中元素的最大值、最小值、平均数、总和等
 * 
 * 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
 * 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。	
 * 要求：所有随机数都是两位数。
 * 
 * [10,99]
 * 公式：(int)(Math.random() * (99 - 10 + 1) + 10)
 * 
 */
public class ArrayTest1 {
    
    
	public static void main(String[] args) {
    
    
		int[] arr = new int[10];
		
		for(int i = 0;i < arr.length;i++){
    
    
			arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
		}
		
		//遍历
		for(int i = 0;i < arr.length;i++){
    
    
			System.out.print(arr[i] + "\t");
		}
		System.out.println();
		
		//求数组元素的最大值
		int maxValue = arr[0];//注意这个地方写 0，如果里面的值都是负数无法比较。
		for(int i = 1;i < arr.length;i++){
    
    
			if(maxValue < arr[i]){
    
    
				maxValue = arr[i];
			}
		}
		System.out.println("最大值为：" + maxValue);
		
		//求数组元素的最小值
		int minValue = arr[0];
		for(int i = 1;i < arr.length;i++){
    
    
			if(minValue > arr[i]){
    
    
				minValue = arr[i];
			}
		}
		System.out.println("最小值为：" + minValue);
		//求数组元素的总和
		int sum = 0;
		for(int i = 0;i < arr.length;i++){
    
    
			sum += arr[i];
		}
		System.out.println("总和为：" + sum);
		//求数组元素的平均数
		int avgValue = sum / arr.length;
		System.out.println("平均数为：" + avgValue);
	}
}

4.7.7 演習 6: 配列の割り当ての説明

package com.atguigu.exer;
/*
 * 使用简单数组
(1)创建一个名为ArrayExer2的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。
 * 
 * 思考：array1和array2是什么关系？array1和array2地址值相同，都指向了堆空间的唯一的一个数组实体。
 * 拓展：修改题目，实现array2对array1数组的复制
 */
public class ArrayExer2 {
    
    
	public static void main(String[] args) {
    
      //alt + /
		int[] array1,array2;
		
		array1 = new int[]{
    
    2,3,5,7,11,13,17,19};
		
		//显示array1的内容
		for(int i = 0;i < array1.length;i++){
    
    
			System.out.print(array1[i] + "\t");
		}
		
		//赋值array2变量等于array1
		//不能称作数组的复制。
		array2 = array1;
		
		/*修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)
		 即下标为偶数时，元素值等于它本身的下标值。
		*/
		for(int i = 0;i < array2.length;i++){
    
    
			if(i % 2 == 0){
    
    
				array2[i] = i;
			}
			
		}
		System.out.println();
		//打印出array1，发现结果和修改后的array2结果相同
		for(int i = 0;i < array1.length;i++){
    
    
			System.out.print(array1[i] + "\t");
		}
	}
}

説明: オブジェクトは一度だけ新規であるため、ヒープ内には値が 1 つだけあります。
array1 = new int[]{2,3,5,7,11,13,17,19};
array2 = array1;
これら 2 つの手順は、ヒープのアドレス値を array1 に割り当て、次に array1 のアドレス値を割り当てることを意味します。この時点では、 array1 と array2 は同じアドレス値を持ちます。array2 の値を変更すると、ヒープ内に値が 1 つだけ存在することになるため、当然、array1 の値も変更されます。
現実の例: これは、ディスク上にファイルを作成し、デスクトップ ショートカットを送信することに相当します。デスクトップ上で開くファイルとディスク上で開くファイルの内容は同じです。

4.7.8 演習 7: 配列のコピー逆検索 (行の二等分)

package com.atguigu.java;
/*
 * 算法的考查：数组的复制、反转、查找(线性查找、二分法查找)
 * 
 * 
 */
public class ArrayTest2 {
    
    
	
	public static void main(String[] args) {
    
    
		
		String[] arr = new String[]{
    
    "JJ","DD","MM","BB","GG","AA"};
		
		
		//数组的复制(区别于数组变量的赋值：arr1 = arr)
		//相当于磁盘文件复制到桌面一份，对桌面的文件进行修改
		String[] arr1 = new String[arr.length];
		for(int i = 0;i < arr1.length;i++){
    
    
			arr1[i] = arr[i];
		}
		
		//数组的反转
		/*方法一：不管是除进还是除不尽都不影响，除于2是因为 第一步第一个元素和最后一个进行交换
		最后一步 最后一个与第一个进行交换，相当于交换了2次。*/
//		for(int i = 0;i < arr.length / 2;i++){
    
    
//			String temp = arr[i];
//			arr[i] = arr[arr.length - i -1]; 把最后元素赋值给第一个
//			arr[arr.length - i -1] = temp; 把第一个交换给第二个
//		}
		
		//方法二：
//		for(int i = 0,j = arr.length - 1;i < j;i++,j--){
    
    
//			String temp = arr[i];
//			arr[i] = arr[j];
//			arr[j] = temp;
//		}
		
		//遍历
		for(int i = 0;i < arr.length;i++){
    
    
			System.out.print(arr[i] + "\t");
		}
		
		System.out.println();
		//查找（或搜索）
		//线性查找：重头到尾依次查找
		String dest = "BB";
		dest = "CC";
		
		boolean isFlag = true;
		
		for(int i = 0;i < arr.length;i++){
    
    
			
			if(dest.equals(arr[i])){
    
    
				System.out.println("找到了指定的元素，位置为：" + i);
				isFlag = false;
				break;
			}
			
		}
		if(isFlag){
    
    
			System.out.println("很遗憾，没有找到的啦！");
			
		}
		//二分法查找：(熟悉)先分为2半，如果查找的第1份有对应值，则另一份就不找了。效率更高
		//前提：所要查找的数组必须有序。
		int[] arr2 = new int[]{
    
    -98,-34,2,34,54,66,79,105,210,333};
		
		int dest1 = -34;
		dest1 = 35;
		int head = 0;//初始的首索引
		int end = arr2.length - 1;//初始的末索引
		boolean isFlag1 = true;
		while(head <= end){
    
    
			
			int middle = (head + end)/2;    //4
			
			if(dest1 == arr2[middle]){
    
    
				System.out.println("找到了指定的元素，位置为：" + middle);
				isFlag1 = false;
				break;
			}else if(arr2[middle] > dest1){
    
    
				end = middle - 1;
			}else{
    
    //arr2[middle] < dest1
				head = middle + 1;
			}

			
		}
		
		if(isFlag1){
    
    
			System.out.println("很遗憾，没有找到的啦！");
		}
		
		
	}
}

4.8 配列ツールクラス 配列

java.util.Arrays : 配列を操作するためのツール クラス。配列を操作するための多くのメソッドを定義します。

注: 配列の並べ替え、コピー、二等分アルゴリズムなどはカプセル化されており、これらを使用する場合は、上記の手書きとは異なり、ツール クラスのメソッドを直接呼び出すことができます。開発中に、ツール クラスに対応するメソッドがある場合は、ツール クラスを使用して自分で作成します。

4.8.1 Arrays.toString(配列)

配列内のデータをカンマを使用して文字列に連結します。（戻り値は文字列）
形式：[10, 14, 20, 46, 51]

package day006;
 
import java.util.Arrays;
 
public class Test02 {
    
    
 
	public static void main(String[] args) {
    
    
		// to String
		method();
 
	}
	public static void method() {
    
    
		int[] aa= {
    
    1,2,3,4,5,6};
//直接输出整个数组不需要遍历，之前遍历是插入。		
//		for(int i=0;i<aa.length-1;i++) {
    
    
//		}
        //直接打印是地址值如:[I@15db9742使用工具类后是：[1, 2, 3, 4, 5, 6]                                           
		System.out.println(Arrays.toString(aa));
	}   
 
}

4.8.2 配列.sort(配列)

配列を昇順に並べ替える: 基本型の配列に最適化された、非常に効率的なクイック ソート アルゴリズムを使用します。参照型配列の場合は、最適化されたマージ ソート アルゴリズムを使用します。

戻り値なし。
例：

package lianxi;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class Ta {
    
    

	public static void main(String[] args) {
    
    
		int[] as = {
    
    4,9,4,1,2,5,9,6,4,5,2};
		Arrays.sort(as);
	    System.out.println(Arrays.toString(as));
	}
	
}

4.8.3 Arrays.copyOf(配列、新しい長さ)

配列を指定された長さの新しい配列にコピーします。(新しい配列のみが変更され、元の配列は変更されていません)
新しい配列の長さは元の配列よりも大きくなっています。これは、位置をコピーして増加することと同じです。--配列の拡張
新しい配列の長さは元の配列よりも小さくなり、これはデータの前の部分をインターセプトすることと同じです。--配列の縮小
戻り値がある。

4.8.4 toString、sort、copyOf のテスト

package cn.tedu.array;
 
import java.util.Arrays;
 
//测试数组工具类
//为什么sort()没有返回值是，void
//为什么copyOf()有返回值，如：int[]
//原因是：sort()在原数组基础上，把数组调整位置
//copyOf():数组一旦创建，长度不可变！！！所以必须把产生的新数组返回/而这里改变了长度。
public class Test4_Arrays {
    
    
    public static void main(String[] args) {
    
    
       int[] a = {
    
    97, 7, 41, 37, 55, 3, 3, 34, 34, 83};
      
//     sortArray(a);//a是实参，给无序数组排序
      
       int[] newA = copyArray(a);//数组复制a是原数组
//     [97, 7, 41, 37, 55, 3, 3, 34, 34, 83, 0, 0, 0, 0, 0]
//     [97, 7, 41, 37, 55]
       System.out.println(Arrays.toString(newA));
      
    }
   
    //创建copyArray第一种方式，可以扩容，缩容（及新数组的长度大于小于新数组的长度都可以）
    public static int[] copyArray(int[] from) {
    
    
      
       //copyOf(from，num)--from是原数组名，num是新数组长度  -- 新数组长度 > 原数组长度  -- 扩容
       int[] to = Arrays.copyOf(from, 15);
//     [97, 7, 41, 37, 55, 3, 3, 34, 34, 83, 0, 0, 0, 0, 0]
      
       //from是原数组名，5是新数组长度  -- 新数组长度 < 原数组长度 -- 缩容  --相当于截取数据。
       int[] to2 = Arrays.copyOf(from, 5);
//     [97, 7, 41, 37, 55]
      
       return to2;
    }
 
   
   
    //创建sortArray
    public static void sortArray(int[] a) {
    
    //形参
       //sort()用来对无序数组进行排序
       Arrays.sort(a);//底层源码
      
//     [3, 3, 7, 34, 34, 37, 41, 55, 83, 97]
       //toString()对指定的数组内容，显示成字符串
       System.out.println(Arrays.toString(a));
    }
   
   
}
例子：
	//数组的复制 第2种arraycopy   都是在新的数组上改变，注意两者写法的区别。
		int [] we= {
    
    4,8,5,8,9};    //新数组小了自动截取，大了会自动填充。
		int[] we1=Arrays.copyOf(we, 4);
		System.out.println(Arrays.toString(we));
		System.out.println(Arrays.toString(we1));
		
		System.out.println("11111111111");//打桩
		int[] we2=new int[5];//这个是新数组长度小则会有数组下标越界异常。那个不会。优点是显得更灵活。
		System.arraycopy(we,0,we2,0,5);
        System.out.println(Arrays.toString(we2));
        //数组的扩容
        int we3[]=Arrays.copyOf(we, we.length+1);
        System.out.println(Arrays.toString(we3));

4.8.5 配列.等しい

//boolean equals(int[] a,int[] b):判断两个数组是否相等。
		int[] arr1 = new int[]{
    
    1,2,3,4};
		int[] arr2 = new int[]{
    
    1,3,2,4};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);//false

4.8.6 Arrays.fill

int[] arr1 = new int[]{
    
    1,2,3,4};
//void fill(int[] a,int val):将指定值填充到数组之中。
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));//[10, 10, 10, 10]

4.8.7 Arrays.binarySearch バイナリ アルゴリズム検索

//int binarySearch(int[] a,int key)
		int[] arr3 = new int[]{
    
    -98,-34,2,34,54,66,79,105,210,333};
		int index = Arrays.binarySearch(arr3, 210);
		if(index >= 0){
    
    //返回值为整数代表找到，为什么正负代表找到没找到，因为源码是这样设计的
			System.out.println(index);
		}else{
    
    //返回值为负数没找到
			System.out.println("未找到");
		}

4.9 配列における一般的な例外

package com.atguigu.java;
/*
 * 数组中的常见异常：
 * 1. 数组角标越界的异常：ArrayIndexOutOfBoundsExcetion
 * 
 * 2. 空指针异常：NullPointerException
 * 
 */
public class ArrayExceptionTest {
    
    
	public static void main(String[] args) {
    
    
		
		//1. 数组角标越界的异常：ArrayIndexOutOfBoundsExcetion
		int[] arr = new int[]{
    
    1,2,3,4,5};
		
//		for(int i = 0;i <= arr.length;i++){
    
    
//			System.out.println(arr[i]);
//		}
		
//		System.out.println(arr[-2]);
		
//		System.out.println("hello");
		
		//2.2. 空指针异常：NullPointerException
		//情况一：原来有地址，现在改为Null了没有地址，在根据地址值找对的值
//		int[] arr1 = new int[]{1,2,3};
//		arr1 = null;
//		System.out.println(arr1[0]);
		
		//情况二：
//		int[][] arr2 = new int[4][];
//		System.out.println(arr2[0][0]);
		
		//情况三：
		String[] arr3 = new String[]{
    
    "AA","BB","CC"};
		arr3[0] = null;
		System.out.println(arr3[0].toString());
	}
}

4.10 拡張:

4.10.1 2 次元配列について

配列を格納する配列、つまり、配列に格納されるデータは依然として配列の形式です。

ケース 1:

public class Test06 {
    
    
       //ctrl +n   快捷键相当于new在用上下键 （创建项目，包，类全程不用鼠标）
	public static void main(String[] args) {
    
    
		// 二维数组: 数组套数组
		//格式： 定位：如，c[0][1] 遍历2次.
		int [][] c={
    
    {
    
    1,2},{
    
    3,4},{
    
    5,6}};//声明形式
		for(int i=0;i<=c.length-1;i++) {
    
    //遍历外层数组
			for(int j=0;j<=c[i].length-1;j++) {
    
     //遍历内层数组
				System.out.println(c[i][j]);//输出形式
				
			}
			
		}
 

ケース 2:

package com.atguigu.java;
/*
 * 二维数组的使用
 * 
 * 1.理解：
 * 对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
 * 其实，从数组底层的运行机制来看，其实没有多维数组。
 * 
 * 2. 二维数组的使用:
 *   ① 二维数组的声明和初始化
 *   ② 如何调用数组的指定位置的元素
 *   ③ 如何获取数组的长度
 *   ④ 如何遍历数组
 *   ⑤ 数组元素的默认初始化值 :见 ArrayTest3.java
 *   ⑥ 数组的内存解析 :见 ArrayTest3.java
 * 
 * 
 */
public class ArrayTest2 {
    
    
	public static void main(String[] args) {
    
    
		//1.二维数组的声明和初始化
		int[] arr = new int[]{
    
    1,2,3};//一维数组
		//静态初始化
		int[][] arr1 = new int[][]{
    
    {
    
    1,2,3},{
    
    4,5},{
    
    6,7,8}};
		//动态初始化1
		String[][] arr2 = new String[3][2];
		//动态初始化2
		String[][] arr3 = new String[3][];
		//错误的情况 
//		String[][] arr4 = new String[][4];
//		String[4][3] arr5 = new String[][];
//		int[][] arr6 = new int[4][3]{
    
    {1,2,3},{4,5},{6,7,8}};
		
		//也是正确的写法：
		int[] arr4[] = new int[][]{
    
    {
    
    1,2,3},{
    
    4,5,9,10},{
    
    6,7,8}};
		int[] arr5[] = {
    
    {
    
    1,2,3},{
    
    4,5},{
    
    6,7,8}};
		
		//2.如何调用数组的指定位置的元素
		System.out.println(arr1[0][1]);//2
		System.out.println(arr2[1][1]);//null
		
		arr3[1] = new String[4];
		System.out.println(arr3[1][0]);
		
		//3.获取数组的长度
		System.out.println(arr4.length);//3
		System.out.println(arr4[0].length);//3
		System.out.println(arr4[1].length);//4
		
		//4.如何遍历二维数组
		for(int i = 0;i < arr4.length;i++){
    
    
			
			for(int j = 0;j < arr4[i].length;j++){
    
    
				System.out.print(arr4[i][j] + "  ");
			}
			System.out.println();
		}
		
	}
}

ケース 3:

package com.atguigu.java;
/*
 * 二维数组的使用：
 * 	规定：二维数组分为外层数组的元素，内层数组的元素
 * 		int[][] arr = new int[4][3];
 * 		外层元素：arr[0],arr[1]等
 * 		内层元素：arr[0][0],arr[1][2]等
 * 
 *   ⑤ 数组元素的默认初始化值 
 *   针对于初始化方式一：比如：int[][] arr = new int[4][3];
 *      外层元素的初始化值为：地址值
 *      内层元素的初始化值为：与一维数组初始化情况相同
 *      
 *   针对于初始化方式二：比如：int[][] arr = new int[4][];
 *   	外层元素的初始化值为：null
 *      内层元素的初始化值为：不能调用，否则报错。
 *   
 *   ⑥ 数组的内存解析 
 * 
 */
public class ArrayTest3 {
    
    
	public static void main(String[] args) {
    
    
		
		int[][] arr = new int[4][3];
		System.out.println(arr[0]);//[I@15db9742 
		System.out.println(arr[0][0]);//0
		
//		System.out.println(arr);//[[I@6d06d69c
		
		System.out.println("*****************");
		float[][] arr1 = new float[4][3];
		System.out.println(arr1[0]);//地址值
		System.out.println(arr1[0][0]);//0.0
		
		System.out.println("*****************");
		
		String[][] arr2 = new String[4][2];
		System.out.println(arr2[1]);//地址值
		System.out.println(arr2[1][1]);//null
		
		System.out.println("*****************");
		double[][] arr3 = new double[4][];
		System.out.println(arr3[1]);//null
//		System.out.println(arr3[1][0]);//报错
		
	}
}

4.10.2 バブルソートについて

バブル ソートは、コンピューター サイエンスの分野における比較的単純な並べ替えアルゴリズムです。
ソート対象の要素の列を繰り返し訪問し、隣接する 2 つの要素を順番に比較し、順序 (大から小、A から Z の最初の文字など) が間違っている場合はそれらを入れ替えます。要素を訪問する作業は、隣接する要素を交換する必要がなくなるまで繰り返されます。これは、要素がソートされたことを意味します。
このアルゴリズムの名前は、炭酸飲料の二酸化炭素の泡が最終的に上部に浮かぶのと同じように、より大きな要素が交換 (昇順または降順で配置) によってシーケンスの上部にゆっくりと「浮く」という事実に由来しています。したがって、「バブルソート」という名前が付けられています。

バブルソートの説明:

1. 配列内の 2 つの隣接する要素を比較し、最初の数値が 2 番目の数値より大きい場合は、その位置を交換します。
2. 各比較により最大値または最小値が生成されます。
3. 次のラウンドはソートを1回減らすことができます。
4. 最後まで繰り返します。

バブルソートの最適化: たくさんありますが、最も基本的なものは変数の同定によって判定でき、ソートが正しければ比較する必要はありません。

4.10.3 バブルソートコード

package cn.tedu.bubble;
 //第一种 20个数比 20轮   每轮比-i-1次
		//第二种 20个数比19轮    每轮比-i次
import java.util.Arrays;
 
//这个类用来测试冒泡排序算法
public class Test3_Bubble {
    
    
    public static void main(String[] args) {
    
    
       //1，定义无序数组
       int[] a = {
    
    21, 94, 21, 58, 47, 16, 10, 9, 50, 44};
      
       //2，排序
       //5个数，比4轮。外循环控制轮数，让外循环执行4次
       //i < a.length-1   a.length是5，-1 就是 4，i<4，外循环执行4次
       for(int i = 0 ; i < a.length-1 ; i++ ) {
    
    
          
           //内循环控制每轮需要相邻比较多少次
       //-i ：第1轮，需要比4次，五个数参与比较 -0，
           //第2轮，需要比3次，四个数参与比较 -1，(因为第一轮沉出来一个大值不参与比较)
           //第3轮，需要比2次，四个数参与比较 -2，(因为前两轮沉出来两个大值不参与比较)
           //第4轮，需要比1次，四个数参与比较 -3，(因为前三轮沉出来三个大值不参与比较)
           for(int j = 0 ; j < a.length-1 - i; j++ ) {
    
    
              //1，相邻元素比较
              //前一个值a[j]大于后面的值a[j+1]
              if(a[j]>a[j+1]) {
    
    
                  //2,交换顺序s
                  int t = a[j];
                 
                  a[j] = a[j+1];
                 
                  a[j+1] = t;
              }
           }
          
       }
      
      
       System.out.println(Arrays.toString(a));
      
    }
   
}

4.10.4 バブルソートコードを最適化する方法

package lianxi;

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class Ta {
    
    

	public static void main(String[] args) {
    
    
		//1，定义无序数组
	       int[] a = {
    
    21, 94, 21, 58, 47, 16, 10, 9, 50, 44};
	      
	       //2，排序
	       //5个数，比4轮。外循环控制轮数，让外循环执行4次
	       //i < a.length-1   a.length是5，-1 就是 4，i<4，外循环执行4次
	       for(int i = 0 ; i < a.length-1 ; i++ ) {
    
    
	    	   boolean flag=false;//通过flag标识减少没有意义的比较
	          
	           //内循环控制每轮需要相邻比较多少次
	       //-i ：第1轮，需要比4次，五个数参与比较 -0，
	           //第2轮，需要比3次，四个数参与比较 -1，(因为第一轮沉出来一个大值不参与比较)
	           //第3轮，需要比2次，四个数参与比较 -2，(因为前两轮沉出来两个大值不参与比较)
	           //第4轮，需要比1次，四个数参与比较 -3，(因为前三轮沉出来三个大值不参与比较)
	           for(int j = 0 ; j < a.length-1 - i; j++ ) {
    
    
	        	   
	              //1，相邻元素比较
	              //前一个值a[j]大于后面的值a[j+1]
	              if(a[j]>a[j+1]) {
    
    
	                  //2,交换顺序s
	                  int t = a[j];                 
	                  a[j] = a[j+1];                 
	                  a[j+1] = t;
	                  flag=true;
	              }	              
	           }
	           if(flag==false) {
    
    
	            	  break;
	              }	          
	       }	      
	       System.out.println(Arrays.toString(a));
	}	
}

4.10.5 他のアルゴリズムを理解する

例: マージ アルゴリズム、二分アルゴリズム、高速アルゴリズムなど。バブルは最も一般的であり、インタビューでの出現率が最も高いものでもあります。

4.10.6 スパース配列

B ステーション Crazy God スパース配列ビデオリンク: https://www.bilibili.com/video/BV12J41137hu?p=59&spm_id_from=pageDriver