helloworld
class HelloWorld {
public static void main(String[] args) {
System.out.println("helloworld");
}
} 注釋
//注釋：用于解釋說明程式的文字
/*
注釋的分類：
單行注釋 一般用于解釋說明單行程式
格式是：//注釋文字
多行注釋 一般用于解釋說明多行程式
格式是：
文檔注釋 一般是對類或者方法進行說明，被javadoc工具解析生産一個文檔說明書。
格式是：
*/
//注意：多行注釋不能嵌套寫，而單行注釋可以。
//這是我的學生案例
//class是java中用來定義類的
//定義類的格式是：class 類名
/*
這是我的學生案例
class是java中用來定義類的
定義類的格式是：class 類名
*/
/** */
class Student {
public static void main(String[] args) {
System.out.println("我是學生");
}
} 帶注釋的helloworld
/*
需求：我要完成HelloWorld案例
分析：
A:java語言最基本的機關是類，是以我們首先要定義一個類
B:java程式要想能夠獨立運作，必須有主方法
C:如果想要程式有輸出，必須有輸出語句
步驟：
A:定義類的格式
class 類名 {
//類體
}
B:主方法的格式
public static void main(String[] args) {
//方法體
}
C:輸出語句的格式
System.out.println("這裡的内容是可以改");
最後把我們的思想用代碼給展現出來
*/
//這是我的帶注釋的HelloWorld案例
//class用來定義類
class HelloWorld {
/*
這是main方法
main方法是程式的入口
jvm會自動調用main方法
*/
public static void main(String[] args) {
//這是輸出語句
System.out.println("HelloWorld");
}
} /*
注釋的作用：
A:解釋說明程式，提高程式的閱讀性
B:可以幫助我們調試程式
*/
class Demo {
public static void main(String[] args) {
System.out.println("HelloWorld");
System.out.print("我愛林青霞"); //println與print差別在于換行與非換行
System.out.print("我愛Java");
System.out.print("我愛張瑜");
}
} 關鍵字
/*
關鍵字：被Java語言賦予特定含義的單詞
關鍵字的特點：關鍵字都是小寫的
關鍵字注意事項
A:goto和const作為保留字存在,目前并不使用
B:類似Editplus這樣的進階記事本,針對關鍵字有特殊的顔色标記，非常直覺
*/
class KeyWord {
public static void main(String[] args) {
System.out.println("HelloWorld");
}
} 辨別符
/*
辨別符：就是給類,接口,方法,變量等起名字時使用的字元序列(字元串)
組成規則：
A:英文字母大小寫
B:數字
C:_和$
注意事項：
A:不能以數字開頭
B:不能是Java中的關鍵字
C:區分大小寫
Student,student 這是兩個名稱
常見的命名規則：見名知意
A:包 其實就是檔案夾,用于解決相同類名問題
全部小寫
單級：com
多級：cn.itcast
B:類或者接口
一個單詞：首字母大寫
Student,Person,Teacher
多個單詞：每個單詞的首字母大寫
HelloWorld,MyName,NameDemo
C:方法或者變量
一個單詞：全部小寫
name,age,show()
多個單詞：從第二個單詞開始，每個單詞首字母大寫
myName,showAllStudentNames()
D:常量
一個單詞：全部大寫
AGE
多個單詞：每個單詞都大寫，用_連接配接
STUDENT_MAX_AGE
*/
class NameDemo {
public static void main(String[] args) {
System.out.println("Hello World!");
}
} 常量
/*
常量：在程式執行的過程中其值不可以發生改變
舉例：π
分類：
A:字面值常量
1，12.5
B:自定義常量(面向對象部分講解)
字面值常量分類：
A:字元串常量 用""括起來的内容 String
B:整數常量 所有的整數資料 int
C:小數常量 所有的帶小數的資料 float/double
D:字元常量 用單引号括起來的内容 char
E:布爾常量 隻有兩個值：true和false blolean
F:空常量 null(數組部分去講解) null
*/
class ConstantDemo {
public static void main(String[] args) {
//字元串常量
System.out.println("HelloWorld");
//整數常量
System.out.println(100);
//小數常量
System.out.println(12.345);
//字元常量
System.out.println('A');
//下面的是錯誤的
//System.out.println('BC');//此條錯誤
System.out.println('1');
//布爾常量
System.out.println(true);
System.out.println(false);
}
} 進制轉換
/*
二進制
由0,1組成。以0b開頭
八進制
由0,1,…7組成。以0開頭
十進制
由0,1,…9組成。整數預設是十進制的
十六進制
由0,1,…9,a,b,c,d,e,f(大小寫均可)。以0x開頭
*/
class JinZhiDemo {
public static void main(String[] args) {
System.out.println(0b100);//4
System.out.println(0100);//64
System.out.println(100);//100
System.out.println(0x100);//256
}
} 變量
/*
成員變量和局部變量的差別：
A:在類中的位置不同
成員變量 類中方法外
局部變量 方法内或者方法聲明上
B:在記憶體中的位置不同
成員變量 堆記憶體
局部變量 棧記憶體
C:生命周期不同
成員變量 随着對象的存在而存在，随着對象的消失而消失
局部變量 随着方法的調用而存在，随着方法的調用完畢而消失
D:初始化值不同
成員變量 有預設的初始化值
局部變量 沒有預設的初始化值，必須先定義，指派，才能使用。
注意：
如果有同名的變量，一般會采用就近原則。
*/
class VariableDemo {
//成員變量 堆記憶體
int x;
public static void main(String[] args) {
//局部變量 棧記憶體
int y;
y = 0; //如果不指派,将報錯,成員變量有預設初始值.
System.out.println(y);
VariableDemo vd = new VariableDemo();
System.out.println(vd.x);
}
} 資料類型
/*
為了更好的表達現實世界的事物，Java針對不同的事物提供了不同的資料類型。
資料類型：
基本類型：4類8種
引用類型：類，接口，數組。(後面講)
基本類型:
整數： 占用的記憶體空間
byte 1位元組
01111111
10000000(1既表示符号位，又表示數值 -128)
short 2位元組
int 4位元組
long 8位元組
浮點數：
float 4位元組
double 8位元組
字元：
char 2位元組
布爾：
boolean 未知。1位元組
面試題：
Java中字元可以存儲一個漢字嗎?
可以。因為Java語言采用的是unicode編碼，
而unicode編碼的每個字元是兩個位元組，
是以，java中的字元可以存儲一個漢字。
注意：
整數預設是int類型
浮點數預設是double類型
long類型的變量，要加l或者L。
float類型的變量，要加f或者F。
在同一對{}裡面，是不能有同名的變量。
*/
class DataType {
public static void main(String[] args) {
//定義變量的格式：
//資料類型 變量名 = 初始化值;
//定義byte類型的變量
byte b = 1;
System.out.println(1);
System.out.println(b);
//定義short類型的變量
short s = 100;
System.out.println(s);
//定義int類型的變量
int i = 100000;
System.out.println(i);
//報錯
//int j = 2147483648;
//System.out.println(j);
//定義long類型的變量
long l = 2147483648L;
System.out.println(l);
//定義float類型的變量
float f = 12.34F;
System.out.println(f);
//定義double類型的變量
double d = 23.56;
System.out.println(d);
//定義char類型的變量
char ch = 'a';
System.out.println(ch);
//定義boolean類型的變量
boolean flag = true;
System.out.println(flag);
}
} 類型轉換
/*
+是一個運算符, 我們應該能夠看懂，做資料的加法。
參與運算的資料，要求類型一緻。
boolean類型不能轉換為其他的資料類型。
隐式轉換：
A:byte,short,char-->int-->long-->float-->double
B:byte,short,char互相之間不轉換，他們參與運算首先轉換為int類型
*/
class DataTypeDemo {
public static void main(String[] args) {
//類型一樣的資料
int a = 10;
int b = 20;
System.out.println(a + b);
int c = a + b;
System.out.println(c);
System.out.println("--------------");
//定義變量
byte by = 3;
int i = 4;
System.out.println(by + i);
int j = by + i;
System.out.println(j);
}
} /*
強制轉換:從大到小，不建議使用，因為可能有精度的丢失。
目标類型 變量名=(目标類型)(被轉換的資料);
*/
class DataTypeDemo2 {
public static void main(String[] args) {
//定義變量
byte by = 3;
int i = 4;
byte bb = (byte)(by + i);
System.out.println(bb);
}
} /*
+:做加法操作
A:針對資料操作
B:針對字元進行做+
ASCII碼表
'0' 48
'A' 65
'a' 97
C:針對字元串進行做+
在字元串的操作中，叫字元串連接配接符
*/
class DataTypeDemo3 {
public static void main(String[] args) {
System.out.println('a');
System.out.println('a'+1);
System.out.println('A'+0);
System.out.println('0'+0);
System.out.println("-----------");
System.out.println('a'+'b');
System.out.println("a"+"b");
System.out.println("hello"+'a'+1); //左邊字元串，往後拼的都是字元串
System.out.println('a'+1+"hello");
System.out.println("5+5="+5+5);
System.out.println(5+5+"=5+5");
}
} /*
byte b1=3,b2=4,b;
b=b1+b2;
b=3+4;
哪句是編譯失敗的呢？為什麼呢？
b=b1+b2;
原因：
變量相加，它首先提示類型，再做操作。
常量相加，它先做操作，然後判斷結果是否在左邊的範圍内容，如果在就不報錯。如果不在，報錯。
*/
class DataTypeTest {
public static void main(String[] args) {
byte b1=3,b2=4,b;
//b = b1+b2; //右邊類型自動提升
b = 3+4;
}
} /*
byte b = 130;有沒有問題?如果我想讓指派正确，可以怎麼做?結果是多少呢?
*/
class DataTypeTest2 {
public static void main(String[] args) {
//byte b = 130;
//解決方案
//方案1
//int a = 130;
//方案2
byte b = (byte) 130;
System.out.println(b);
}
}
/*
十進制：130
A:第一步，先把十進制轉換為二進制
二進制：000000000 000000000 000000000 100000010
由于此二進制是一個正數，是以，補碼也是000000000 000000000 000000000 100000010。
B:做強制類型轉換
二進制：000000000 000000000 000000000 100000010
截取後就變成了：100000010
C:操作後的資料是補碼，你看到的是原碼
符号位 數值位
補碼： 1 00000010
反碼： 1 00000001
原碼： 1 11111110
*/ class DataTypeTest3 {
public static void main(String[] args) {
byte b = (byte)300;
System.out.println(b);
System.out.println((byte)127);
System.out.println((byte)128);
System.out.println((byte)129);
System.out.println((byte)130);
System.out.println((byte)131);
}
}
/*
十進制：300
A:把十進制轉換為二進制
00000000 00000000 00000001 00101100
B:截取
0 0101100
*/ 算數運算符
/*
運算：對常量和變量進行操作的過程稱為運算。
運算符：對常量和變量進行操作的符号稱為運算符
表達式：由運算符把常量和變量連接配接起來的式子
a + b
注意：表達式必須有結果
常見的運算符：
算術運算符
指派運算符
比較運算符
邏輯運算符
位運算符
三目運算符
算術運算符：
+，-，*，/，%，++，--
*/
class OperatorDemo {
public static void main(String[] args) {
System.out.println(10+20);
System.out.println(10-20);
System.out.println(10*20);
//整數相除，隻能得到整數
System.out.println(10/20);
//要想得到小數，可以乘以或者除以1.0
System.out.println(10/1.0/20);
//加法的用法:正号,加法,字元串連接配接符
System.out.println(+5);
System.out.println(1+2);
System.out.println("1"+"2");
}
} 指派運算符
/*
指派運算符：
基本：=
複合：+=,-=,*=,/=,%=,...
*/
class OperatorDemo {
public static void main(String[] args) {
//把10指派給int類型的變量a
int a = 10;
//複合的用法
int b = 10;
b += 20; //結果等價于：b = b + 20;
System.out.println(b);
}
} 關系運算符
/*
關系運算符：
==,!=,>,>=,<,<=
特點：
無論表達式是簡單還是複雜，結果肯定是boolean類型。
注意事項：
關系運算符“==”不能誤寫成“=” 。
*/
class OperatorDemo {
public static void main(String[] args) {
int a = 10;
int b = 10;
int c = 20;
System.out.println(a == b);
System.out.println(a == c);
System.out.println((a + b*c) == (a*b + c));
System.out.println("----------------");
System.out.println(a = b); //把b的值指派給a，把a的值作為結果留下來
System.out.println(a = c);
}
} 邏輯運算符
/*
邏輯運算符：
&,|,!,^
&&,||
注意：
邏輯運算符連接配接的應該是一個布爾表達式。
*/
class OperatorDemo {
public static void main(String[] args) {
//&,|,!,^
int a = 10;
int b = 20;
int c = 30;
//&:邏輯與 有false則false
System.out.println(a>b & a>c); //false & false = false
System.out.println(a>b & a<c); //false & true = false
System.out.println(a<b & a>c); //true & false = false
System.out.println(a<b & a<c); //true & true = true
System.out.println("--------");
//|:邏輯或 有true則true
System.out.println(a>b | a>c); //false | false = false
System.out.println(a>b | a<c); //false | true = true
System.out.println(a<b | a>c); //true | false = true
System.out.println(a<b | a<c); //true | true = true
System.out.println("--------");
//^:邏輯異或 相同false，不同true。
//情侶：男男，男女，女男，女女
System.out.println(a>b ^ a>c); //false ^ false = false
System.out.println(a>b ^ a<c); //false ^ true = true
System.out.println(a<b ^ a>c); //true ^ false = true
System.out.println(a<b ^ a<c); //true ^ true = false
System.out.println("--------");
//!:邏輯非
System.out.println((a>b));//false
System.out.println(!(a>b));//true
System.out.println(!!(a>b));//false
System.out.println(!!!(a>b));//true
System.out.println(!!!!(a>b));//false
}
} 位運算符
/*
位運算符：位運算符一定是先把資料轉成二進制，然後再運算。
面試題：&和&&的差別?
A:&和&&都可以作為邏輯運算，&&具有短路效果。
B:&還可以作為位運算。
*/
class OperatorDemo {
public static void main(String[] args) {
//&,|,^,~
System.out.println(3 & 4); //0
System.out.println(3 | 4); //7
System.out.println(3 ^ 4); //7
System.out.println(~3); //
}
}
/*
A:計算出3，4的二進制
3的二進制：00000000 00000000 00000000 00000011
4的二進制：00000000 00000000 00000000 00000100
B:位&運算 有0則0
00000000 00000000 00000000 00000011
&00000000 00000000 00000000 00000100
------------------------------------
00000000 00000000 00000000 00000000
C:位|運算 有1則1
00000000 00000000 00000000 00000011
&00000000 00000000 00000000 00000100
------------------------------------
00000000 00000000 00000000 00000111
D:位^運算 相同則0，不同則1
00000000 00000000 00000000 00000011
&00000000 00000000 00000000 00000100
------------------------------------
00000000 00000000 00000000 00000111
E:位~運算 把資料每個位都按位取反
00000000 00000000 00000000 00000011
~11111111 11111111 11111111 11111100
反:11111111 11111111 11111111 11111011
原:10000000 00000000 00000000 00000100
*/ 三元運算符
/*
三元運算符：
格式
(關系表達式)?表達式1：表達式2；
執行流程：
計算關系表達式，看其傳回值
true:表達式1就是整個表達式的值
false:表達式2就是整個表達式的值
*/
class OperatorDemo {
public static void main(String[] args) {
//擷取兩個資料中的較大值
int x = 3;
int y = 4;
int z = (x > y)? x : y;
System.out.println(z);
//比較兩個數是否相等
int a = 4;
int b = 4;
//boolean flag = (a==b)?true:false;
boolean flag = (a == b);
System.out.println(flag);
//擷取三個資料中的較大值
int c = 30;
int d = 40;
int e = 50;
//int max = (c>d)?(c>e?c:e):(d>e?d:e);
int temp = (c>d)?c:d;
int max = (temp>e)?temp:e;
System.out.println(max);
}
} 鍵盤錄入資料
/*
為了程式的資料更加的靈活，我們決定加入鍵盤錄入資料。
如何使用鍵盤錄入資料呢?目前你就給我記住了。
A:導包
import java.util.Scanner;
在class的上面
B:建立對象
Scanner sc = new Scanner(System.in);
C:擷取資料
int i = sc.nextInt();
*/
import java.util.Scanner;
class OperatorDemo {
public static void main(String[] args) {
//建立鍵盤錄入對象
Scanner sc = new Scanner(System.in);
System.out.println("請輸入一個整數：");
//擷取資料
int i = sc.nextInt();
System.out.println("i:"+i);
}
} 順序結構語句
/*
是程式中最簡單最基本的流程控制，沒有特定的文法結構，按照代碼的先後順序，
依次執行，程式中大多數的代碼都是這樣執行的。
總的來說：寫在前面的先執行，寫在後面的後執行
*/
class OrderDemo {
public static void main(String[] args) {
System.out.println("我愛林青霞");
System.out.println("我愛Java");
System.out.println("我愛張曼玉");
System.out.println("林青霞愛張曼玉");
}
} 選擇結構（if語句）
/*
選擇結構：if語句，switch語句。
if語句有三種格式。
if語句格式1：
if(關系表達式) {
語句體;
}
執行流程：
A:計算關系表達式，看其結果
B:如果是true，就執行語句體
如果是false，就不執行語句體
C:繼續向下執行
*/
class IfDemo {
public static void main(String[] args) {
int x = 3;
if(x == 3) {
System.out.println("x等于3");
//x = 10;
}
if(x > 5) {
System.out.println("x大于5");
}
System.out.println("over");
}
} 選擇結構（switch語句）
/*
switch語句格式：
switch(表達式) {
case 值1：
語句體1;
break;
case 值2：
語句體2;
break;
…
default：
語句體n+1;
break;
}
格式解釋：
A:switch表示這是switch語句
B:表達式的取值
byte,short,int,char
JDK5以後可以是枚舉類型。(enum)
JDK7以後可以是字元串。(String)
C:case後面跟的是要和表達式進行比較的值
D:語句體可以是多條語句
E:break表示中斷，結束的意思，可以結束switch語句
F:default語句表示所有情況都不比對的時候，就執行該處的内容，和if語句的else相似。
面試題：
switch的表達式可以是byte類型嗎?可以是long類型嗎?可以是String類型嗎?
可以。
不可以。
JDK7以後可以。
執行流程：
A:首先計算出表達式的值
B:其次，和case依次比較，一旦有對應的值，就會執行相應的語句，
在執行的過程中，遇到break就會結束。
C:最後，如果所有的case都和表達式的值不比對，就會執行default語句體部分，然後程式結束掉。
需求：根據鍵盤錄入的數值1，2，3，…7輸出對應的星期一，星期二，星期三…星期日。
分析：
A:鍵盤錄入資料，用Scanner實作
B:對錄入的資料進行判斷，用switch實作
C:輸出對應的結果
*/
import java.util.Scanner;
class SwitchDemo {
public static void main(String[] args) {
//建立鍵盤錄入對象
Scanner sc = new Scanner(System.in);
//鍵盤錄入資料
System.out.println("請輸入一個資料(1-7)：");
int week = sc.nextInt();
//用switch語句實作
switch(week) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("你輸入的資料有誤");
break;
}
}
} 循環語句（for）
/*
for循環的格式：
for(初始化語句;判斷條件語句;控制條件語句) {
循環體語句;
}
執行流程：
A:首先執行初始化語句
B:其次執行判斷條件語句，看其傳回值
如果是true，就繼續
如果是false，循環結束
C:執行循環體語句
D:執行控制條件語句
E:回到B
*/
class ForDemo2 {
public static void main(String[] args) {
//在控制台輸出10次HelloWorld
for(int x=0; x<10; x++) {
System.out.println("HelloWorld");
}
System.out.println("--------------");
//初始化不從0開始
for(int x=1; x<=10; x++) {
System.out.println("HelloWorld");
}
for(int x=1; x<11; x++) {
System.out.println("HelloWorld");
}
for(int x=10; x>0; x--) {
System.out.println("HelloWorld");
}
}
} 循環語句（while）
/*
while循環的格式：
while(條件表達式) {
語句體;
}
變形格式：
初始化語句;
while(判斷條件語句) {
循環體語句;
控制條件語句;
}
for(初始化語句;判斷條件語句;控制條件語句) {
循環體語句;
}
由此可見while循環和for循環是可以等價轉換的。
*/
class WhileDemo {
public static void main(String[] args) {
//for
/*
for(int x=0; x<10; x++) {
System.out.println("HelloWorld");
}
System.out.println("--------------");
*/
//while
/*
int x=0;
while(x<10) {
System.out.println("HelloWorld");
x++;
}
*/
//求和
//for
/*
int sum = 0;
for(int x=1; x<=100; x++) {
sum+=x;
}
System.out.println("1-100之和是："+sum);
*/
//while
/*
int sum = 0;
int x = 1;
while(x<=100) {
sum += x;
x++;
}
System.out.println("1-100之和是："+sum);
*/
//水仙花
//for
/*
for(int x=100; x<1000; x++) {
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
if(x == (ge*ge*ge + shi*shi*shi + bai*bai*bai)) {
System.out.println(x);
}
}
*/
//while
int x = 100;
while(x<1000) {
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
if(x == (ge*ge*ge + shi*shi*shi + bai*bai*bai)) {
System.out.println(x);
}
x++;
}
}
} 循環語句（do…while）
/*
do...while格式：
do {
語句體;
}while(條件表達式);
變形格式：
初始化語句;
do {
循環體語句;
控制條件語句;
}while(判斷條件語句);
for(初始化語句;判斷條件語句;控制條件語句) {
循環體語句;
}
*/
class DoWhileDemo {
public static void main(String[] args) {
/*
int sum = 0;
for(int x=1; x<=100; x++) {
sum+=x;
}
System.out.println(sum);
*/
//do...while
int sum = 0;
int x = 1;
do{
sum+=x;
x++;
}while (x<=100);
System.out.println(sum);
}
} 循環語句（嵌套使用）
/*
需求：請輸出如下圖形
*
**
***
****
*****
*/
class ForForDemo2 {
public static void main(String[] args) {
//我們先輸出一個5行5列的星形
/*
for(int x=0; x<5; x++) {
for(int y=0; y<5; y++) {
System.out.print("*");
}
System.out.println();
}
*/
//而我們現在需要的是下半部分
//通過觀察圖形：我們知道行沒有變化，是列在變化
//第一行：1列
//第二行：2列
//第三行：3列
//第四行：4列
//第五行：5列
//既然是一個變化的數，那麼我們就定義一個變量
/*
int z = 0;
for(int x=0; x<5; x++) {
for(int y=0; y<=z; y++) {
System.out.print("*");
}
System.out.println();
z++;
}
*/
//我們發現z的變化和x的變化其實是一緻的
//是以我們根本就沒有必要定義z變量，直接把z用x替換
for(int x=0; x<5; x++) {
for(int y=0; y<=x; y++) {
System.out.print("*");
}
System.out.println();
}
System.out.println("---------");
for(int x=1; x<=5; x++) {
for(int y=1; y<=x; y++) {
System.out.print("*");
}
System.out.println();
}
}
} 控制跳轉語句
/*
根據要求填空
*/
class BreakAndContinue {
public static void main(String[] args) {
for(int x=1; x<=10; x++) {
if(x%3==0) {
//在此處填寫代碼
break;
//continue;
//System.out.println("Java基礎班");
}
System.out.println("Java基礎班");
}
//我想在控制台輸出2次:“Java基礎班“
//我想在控制台輸出7次:“Java基礎班“
//我想在控制台輸出13次:“Java基礎班“
}
} /*
break:中斷
break的使用場景：
A:在選擇結構switch語句中
B:在循環語句中
離開使用場景的存在是沒有意義的
break:
A:跳出單層循環
B:跳出多層循環(了解)
帶标簽的用法
*/
class BreakDemo {
public static void main(String[] args) {
for(int x=0; x<10; x++) {
//System.out.println(x);
if(x%2==0) {
break;
//break後面是不能有東西的
//System.out.println(x);
}
System.out.println(x);
}
System.out.println("-------------");
wc:for(int x=0; x<3; x++) {
nc:for(int y=0; y<4; y++) {
System.out.print("*");
break;
}
System.out.println();
}
}
} /*
continue的使用場景：
在循環語句中
離開使用場景的存在是沒有意義的
continue的作用：
A:單層循環對比break，然後總結兩個的差別
break 退出目前循環
continue 退出本次循環
B:也可以帶标簽的使用
*/
class ContinueDemo {
public static void main(String[] args) {
//continue;
for(int x=0; x<10; x++) {
if(x%2==0) {
//break; //結束目前循環
continue; //結束本次循環操作，進入下一次操作
}
System.out.println(x);
}
wc:for(int x=0; x<3; x++) {
nc:for(int y=0; y<4; y++) {
System.out.print("*");
continue wc;
}
System.out.println();
}
}
} /*
return：結束方法的。
*/
class ReturnDemo {
public static void main(String[] args) {
for(int x=0; x<10; x++) {
if(x%3==0) {
//break;
//continue;
return;
}
System.out.println(x);
}
System.out.println("over");
}
} 方法
/*
方法：完成特定功能的代碼塊
格式：
修飾符 傳回值類型 方法名(參數類型 參數名1，參數類型 參數名2…) {
方法體;
return 傳回值;
}
修飾符：public static
傳回值類型：功能最終的值的資料類型
方法名：是為了友善調用而起的一個名字
參數：
形式參數：用于接受實際參數的變量
實際參數：實際參與運算的資料
方法體：完成特定功能的代碼
return 傳回值：通過return把結果傳回給調用者
我們雖然知道了方法的格式，那麼我們該如何寫一個方法呢?
兩個明确：
A:傳回值類型
結果的資料類型
B:參數清單
有幾個參數參加，并且每個參數的資料類型是什麼
需求：求兩個資料之和的案例
A:我沒有說資料的類型，預設int類型。
B:求兩個資料的和
說明有兩個參數參加，并且預設都是int類型
C:兩個int類型相加的結果是什麼類型呢?
是int類型，是以傳回值類型這裡是int類型
方法的執行特點：
不調用不執行。
有明确傳回值的方法的調用：
A:單獨調用，沒有意義。
B:輸出調用，不是很好，因為我們可能需要針對結果還要進行其他的操作。
C:指派調用，推薦方式。
*/
class MethodDemo {
public static void main(String[] args) {
//定義兩個變量
int x = 10;
int y = 20;
//單獨調用
//sum(x,y);
//輸出調用
System.out.println(sum(x,y));
//指派調用
int result = sum(x,y);
//result進行操作
System.out.println(result);
}
//如果我自己要想寫一個方法
public static int sum(int a,int b) {
int c = a + b;
return c;
}
} 方法重載
/*
方法重載：
在同一個類中，允許存在一個以上的同名方法，隻要它們的參數個數或者參數類型不同即可。
和傳回值類型無關。
*/
class MethodDemo {
public static void main(String[] args) {
//需求：請寫一個功能，實作兩個資料的求和
System.out.println(sum(10,20));
//需求：請寫一個功能，實作三個資料的求和
//System.out.println(sum2(10,20,30));
System.out.println(sum(10,20,30));
System.out.println(sum(1.5,2.5));
}
public static int sum(int a,int b) {
return a + b;
}
/*
public static int sum2(int a,int b,int c) {
return a + b + c;
//方法的嵌套調用
//return sum(sum(a,b),c);
}
*/
//由于方法名要表達的其實是該方法的作用
//是以，sum2這個名字不好，還是要用sum 比較好
public static int sum(int a,int b,int c) {
return a + b + c;
}
public static double sum(double a,double b) {
return a + b;
}
} 一維數組
/*
數組：存儲同一種資料類型的多個元素的集合。(也可以稱為容器)
數組的定義格式：
格式1：資料類型[] 數組名;
int[] arr;
格式2：資料類型 數組名[];
int arr[];
推薦方式1。
現在的數組沒有元素，使用是沒有意義的。
接下來，我們要對數組進行初始化。
那麼，我們如何對數組進行初始化呢?
動态初始化：初始化時隻指定數組長度，由系統為數組配置設定初始值。
靜态初始化：初始化時指定每個數組元素的初始值，由系統決定數組長度。
動态初始化：
資料類型[] 數組名 = new 資料類型[數組長度];
*/
class ArrayDemo {
public static void main(String[] args) {
//按照動态初始化數組的格式，我們來定義一個存儲3個int類型元素的數組
int[] arr = new int[3];
/*
左邊：
int:說明數組中的元素的資料類型。
[]:說明這是一個數組
arr:數組的名稱
右邊：
new:為實體(對象)開辟記憶體空間
Scanner sc = new Scanner(System.in);
int:說明數組中的元素的資料類型。
[]:說明這是一個數組
3:說明的是數組中的元素個數
*/
//我們如何擷取裡面的值呢?
//數組名稱
System.out.println(arr); //[I@778b3fee 位址值
//如何擷取元素值呢?
//數組為每個元素配置設定了一個編号，這個編号的專業叫法：索引。
//而且是從0開始編号的。也就是說數組的最大編号是長度-1。
//有了編号以後，我們就可以通過數組名和編号的配合取得數組元素
//格式：數組名[編号];
System.out.println(arr[0]); //0
System.out.println(arr[1]); //0
System.out.println(arr[2]); //0
}
} 二位數組
/*
二維數組：元素為一維數組的數組。
定義格式1：
資料類型[][] 變量名 = new 資料類型[m][n];
m:m表示這個二維數組有多少個一維數組
n:n表示每一個一維數組的元素個數
變形：
資料類型 變量名[][] = new 資料類型[m][n];
資料類型[] 變量名[] = new 資料類型[m][n];
int[] x,y[];
*/
class Array2Demo {
public static void main(String[] args) {
//定義一個二維數組
int[][] arr = new int[3][2];
//表示arr這個二維數組有三個元素
//每個元素是一個一維數組
//每一個一維數組有2個元素
System.out.println(arr); //[[I@778b3fee
System.out.println(arr[0]); //[I@57125f92
System.out.println(arr[1]);
System.out.println(arr[2]);
//如何輸出元素呢?
System.out.println(arr[0][1]);
System.out.println(arr[2][2]);
}
} To be continued
将程式設計看作是一門藝術，而不單單是個技術。
敲打的英文字元是我的黑白琴鍵，
思維圖紙畫出的是我編寫的五線譜。
當美妙的華章響起，現實通往二進制的大門即将被打開。
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)