目錄
1. Java開發環境+HelloWorld
1.1 計算機基礎知識
1.1.1 計算機
1.1.2 計算機硬體
1.1.3 計算機軟體
1.1.4 軟體開發
1.1.5 計算機語言
1.1.6 人機互動方式
1.1.7 鍵盤功能鍵及快捷鍵介紹
1.1.8 常用的DOS指令
1.2 Java語言概述
1.2.1 Java語言發展史
1.2.2 Java語言平台版本
1.2.3 Java語言特點
1.3 JDK
1.3.1 概述
1.3.2 下載下傳與安裝
1.3.3 配置環境變量
1.3.4 目錄介紹
1.4 Eclipse
1.4.1 概述
1.4.2 下載下傳與安裝
1.4.3 工作空間workspace
1.5 HelloWorld案例
1.5.1 建立day01工程
1.5.2 建立包
1.5.3 建立HelloWorld類
1.5.4 建立方法
1.5.5 說明
1.5. 6 運作與工作原理
1.6 拓展：
1.6.1 在自己電腦上安裝jdk
1.6.2 下載下傳最新版本eclipse
1.6.3 JDK JRE JVM的關系
1.6.4 Java的”一次編寫，處處運作”是如何實作的？
2.資料類型+運算符
2.1 前言
2.1.1 辨別符
2.1.2 關鍵字
2.1.3 注釋
2.1.4 變量
2.1.5 常量
2.2 資料類型
2.2.1 基本類型(八種)
2.2.1 引用類型
2.3 基本類型的字面值（5條）
2.3.1 整數字面值是int類型
2.3.2 byte，short，char三種比int小的整數可以用範圍内的值直接指派
2.3.3 浮點數的字面值是double類型
2.3.4 字面值字尾l f d
2.3.5 進制字首
2.4 基本類型的類型轉換
2.4.1 小到大（隐式轉換）
2.4.2 大到小（顯式轉換）
2.5 運算規則（5條）
2.5.1 計算結果的資料類型，與最大類型一緻
2.5.2 byte,short,char三種比int小的整數，運算時會先自動轉換成int
2.5.3 整數運算溢出
2.5.4 浮點數運算不精确
2.5.5 浮點數的特殊值
2.6 拓展
2.6.1 什麼是顯示類型轉換和隐式類型轉換
2.6.2 char 型變量中能不能存儲一個中文漢字，為什麼？
3.方法+流程控制+循環
3.1 運算符
3.1.1 概述
3.1.2 練習1：平年閏年
3.1.3 練習2：自增自減
3.1.4 練習3：求兩個數裡的大值
3.1.5 練習4：求三個數的最大值
3.2 分支結構1：if
3.2.1 概述
3.2.2 形式
3.2.3 練習1：商品打折
3.2.4 練習2：統計學員得分
3.3 [了解]分支結構2：switch
3.3.1 概述
3.3.2 形式
3.3.3 練習1：數字比對
3.4 循環結構1：for
3.4.1 概述
3.4.2 形式
3.4.3 練習1：列印0到10
3.4.4 練習2：列印10到0
3.4.5 練習3：列印8,88,888,8888
3.5 拓展
3.5.1 &和&&的差別
3.5.2 a=a+4和a+=4的差別
3.5.3 求【0,100】中，奇數的個數
3.5.4 求【0,100】中，偶數的和
4.循環+數組
4.1 嵌套for循環
4.1.1 概述
4.1.2 形式
4.1.3 入門案例
4.1.4 練習1：列印正方形
4.1.5 練習2：列印左直角三角形
4.1.6 練習3：列印99乘法表
4.2 break和continue
4.2.1 形式
4.2.2 練習1：找數字88
4.3 循環結構2：while
4.3.1 格式
4.3.2 練習1：猜數字
4.4 循環結構3：do-while
4.4.1 格式
4.4.1 練習1：猜數字
4.5 變量
4.5.1 概念
4.5.2 局部變量
4.5.3 成員變量
4.5.4 測試
4.6 拓展：
4.6.1 三種循環的差別
4.6.2 列印右直角三角形
4.6.3 列印全三角形
5.數組+變量
5.1 方法
5.1.1 概述
5.1.2 形式
5.1.3 練習1：方法調用
5.1.4 練習2：方法參數
5.1.5 練習3：方法傳回值
5.2 方法的重載
5.2.1 概念
5.2.2 練習1：數字求和
5.2.3 練習2：資料的列印
5.3 數組
5.3.1 概念
5.3.2 建立數組
5.3.3 練習1：數組中存入hello
5.3.4 數組的長度
5.4 數組的周遊
5.4.1 形式
5.4.2 練習1：輸出每個月的天數
5.4.3 練習2：周遊數組，存入1到10
5.4.4 練習3：建立随機數組
5.5 數組工具類Arrays
5.5.1 Arrays.toString(數組)
5.5.2 Arrays.sort(數組)
5.5.3 Arrays.copyOf(數組，新的長度)
5.5.4 測試
5.6 拓展：
5.6.1 了解二維數組
5.6.2 了解冒泡排序
5.6.3 了解其他算法
1.Java開發環境+HelloWorld
1.1 計算機基礎知識
1.1.1 計算機
計算機（Computer）全稱：電子計算機，俗稱電腦。是一種能夠按照程式運作，自動、高速處理資料的現代化智能電子裝置。由硬體和軟體所組成，沒有安裝任何軟體的計算機稱為裸機。常見的形式有台式計算機、筆記型電腦。按照規模分為微型機、小型機、大型機、巨型機（超級計算機）等
計算機的應用已滲透到社會的各個領域，正在改變着人們的工作、學習和生活的方式，推動着社會的發展。哪些方面?
1.1.2 計算機硬體
計算機硬體（Computer Hardware）是指計算機系統中由電子，機械和光電元件等組成的各種實體裝置的總稱。這些實體裝置按系統結構的要求構成一個有機整體為計算機軟體運作提供物質基礎
計算機通常由CPU、主機闆、記憶體、電源、主機箱、硬碟、顯示卡、鍵盤、滑鼠，顯示器等多個部件組成
1.1.3 計算機軟體
計算機軟體（Computer Software）是使用計算機過程中必不可少的東西，計算機軟體可以使計算機按照事先預定好的順序完成特定的功能，計算機軟體按照其功能劃分為系統軟體與應用軟體
系統軟體： DOS(Disk Operating System), Windows, Linux, Unix, Mac, Android, iOS
應用軟體：office QQ 英雄聯盟 王者榮耀
1.1.4 軟體開發
軟體：按照特定順序組織的計算機資料和指令的集合
開發：軟體的制作過程
軟體開發：借助開發工具與計算機語言制作軟體
1.1.5 計算機語言
語言：人類進行溝通交流的各種表達符号，友善人與人之間進行溝通與資訊交換
計算機語言：人與計算機之間進行資訊交流溝通的一種特殊語言
計算機語言中也有字元，符号等等
常見的計算機語言如C,C++,C#,JAVA
1.1.6 人機互動方式
軟體的出現實作了人與計算機之間更好的互動
互動方式：圖形化界面：這種方式簡單直覺，使用者易于接受，容易上手操作
指令行方式：需要有一個控制台，輸入特定的指令，讓計算機完成一些操作。較為麻煩，需要記錄住一些指令
1.1.7 鍵盤功能鍵及快捷鍵介紹
Tab
Shift Ctrl Alt
空格 Enter
Window
上下左右
PrtSc(PrintScreen)螢幕截圖
Ctrl+A 全選
Ctrl+C 複制
Ctrl+V 粘貼
Ctrl+X 剪切
Ctrl+Z 撤銷
Ctrl+S 儲存…
1.1.8 常用的DOS指令
打開DOS控制台的方式
常用DOS指令
cmd 進入DOS視窗 #快捷方式，浏覽目錄，直接輸入CMD跳轉
預設是在c盤下，可以切換盤符。
e: 進入e盤
dir 列出目前目錄下的目錄和檔案
mkdir 建立檔案夾
rmdir 删除檔案夾
cd java 進入java目錄
cd .. 退到上層目錄
cd / 退到根目錄
exit : 退出dos指令行
cls : (clear screen)清屏
1.2 Java語言概述
1.2.1 Java語言發展史
詹姆斯·高斯林（James Gosling）1977年獲得了加拿大卡爾加裡大 學計算機科學學士學位，1983年 獲得了美國卡内基梅隆大學計算機科學博士學位，畢業後到IBM工作，設計IBM第一代工作站NeWS系統，但不受重視，後來轉至Sun公司，1990年，與Patrick，Naughton和Mike Sheridan等人合作“綠色計劃”，後來發展一套語言叫做“Oak”，後改名為Java
Java Development Kit
1.0 - 1.1 - 1.2 - 1.3 - 1.4 - 1.5 5.0 - 6.0 - 7.0 - 8.0…..
Sun公司于1995年推出
1991年sun公司James Gosling等人開始開發Oak語言
1994年，将Oak語言更名為Java
1996年獲得第一筆投資1億元
1998年提出jdk1.2，更名為java2
之後推出jdk1.3 jdk1.4
2005年更名為jdk5.0，進行了大幅的版本改進
2006年sun公司宣布将Java作為免費軟體對外釋出
2007年3月起，全世界所有的開發人員均可對Java源代碼進行修改
2007年推出jdk6.0
2009年4月Oracle以74億美元收購了sun公司
2011年7月由Oracle正式釋出jdk7
2014年3月正式釋出了java8
1.2.2 Java語言平台版本
J2SE(Java 2 Platform Standard Edition)标準版
是為開發普通桌面和商務應用程式提供的解決方案，該技術體系是其他兩者的基礎，可以完成一些桌面應用程式的開發
J2ME(Java 2 Platform Micro Edition)小型版
是為開發移動裝置和嵌入式裝置(電器、機器人、機頂盒…)提供的解決方案
J2EE(Java 2 Platform Enterprise Edition)企業版
是為開發企業環境下的應用程式提供的一套解決方案，該技術體系中包含的技術如 Servlet、Jsp等，主要針對于Web應用程式開發
1.2.3 Java語言特點
簡單性 高性能
編譯性 解釋性
面向對象 分布式處理
健壯性 安全性
開源 跨平台
什麼是跨平台性？
通過Java語言編寫的應用程式在不同的系統平台上都可以運作
原理是什麼？
隻要在需要運作java應用程式的作業系統上，先安裝一個Java虛拟機(JVM Java Virtual Machine)即可。由JVM來負責Java程式在該系統中的運作
因為有了JVM，是以同一個Java程式在三個不同的作業系統中都可以執行。這樣就實作了Java程式的跨平台性。也稱為Java具有良好的可移植性
1.3 JDK
1.3.1 概述
JDK是 Java 語言的軟體開發工具包，主要用于移動裝置、嵌入式裝置上的java應用程式。JDK是整個java開發的核心
它包含了:
1、 JAVA開發工具(jdk\bin)
2、 基礎開發庫(jdk\jre\lib\rt.jar)
3、 基礎開發庫的源碼(jdk\src.zip)
1.3.2 下載下傳與安裝
通過官方網站擷取JDK：http://www.oracle.com
也可以通過百度自行搜尋資源
下載下傳完後進行安裝，傻瓜式安裝，下一步下一步即可
注意：
1、 同時安裝多個jdk時需要使用指定環境變量來确認使用的是哪個jdk
2、 安裝路徑不要有中文或者特殊符号如空格等。最好目錄統一
3、 我們也提供了綠色解壓版，不需要安裝直接解壓即可
1.3.3 配置環境變量
JAVA_HOME
該配置是要配置jdk的安裝目錄，來明确要使用哪個版本的jdk
PATH
系統會在path配置的值中，尋找可執行檔案
需要把jdk\bin添加到path中
1.3.4 目錄介紹
1.4 Eclipse
1.4.1 概述
Eclipse 是一個開放源代碼的、基于Java的可擴充開發平台。就其本身而言,它隻是一個架構和一組服務,用于通過插件元件建構開發環境
1.4.2 下載下傳與安裝
1、 官網下載下傳并安裝
2、 下載下傳完整的打封包件（java ee企業版），直接解壓就可以用
1.4.3 工作空間workspace
用來儲存所有的開發檔案和代碼等，也可以切換工作空間
1.5 HelloWorld案例
1.5.1 建立day01工程
1.5.2 建立包
包名全小寫
1.5.3 建立HelloWorld類
類名要符合駝峰命名法
1.5.4 建立方法
class HelloWorld{
public static void main(String [] args){
System.out.println(“Hello World”);
}
}
1.5.5 說明
//單行注釋
/* 多行注釋 */
/*
* 用來定義一個包
* package 加粗變紅的效果，叫做關鍵字。專門用來定義包 。
* cn.tedu.hello 包名 -- 全小寫 + 公司的域名倒着寫
* ; 是Java語句的結束符，相當于。
*/
package cn.tedu.hello;
/*
* 用來定義一個類
* public 是關鍵字，專門用來修飾類的通路權限。公共的
* class 是關鍵字，專門用來定義一個類
* HelloWorld 類名 -- 駝峰命名法
* { java代碼 }
*/
public class HelloWorld {
/*
* 定義一個主函數/主方法/main方法
* public 是關鍵字，專門用來修飾main方法的通路權限。公共的
* static 是關鍵字，修飾main方法是靜态方法
* void 空/無，main方法傳回值是空
* main 方法名
* () 是方法的标志
* String[] args 方法的參數
* { Java代碼/方法體 }
*/
public static void main(String[] args) {
/*
* 用來向控制台輸出指定的資料
* System 要發出系統指令
* out 發出一個輸出的動作
* println 列印後換行
* () 是方法的标志
* "hello java" 方法的參數 -- 要輸出的資料
* ; Java語句的結束符
*/
System.out.println("hello java");
}
}
1.5.6 運作與工作原理
1、 編譯：通過javac指令将java的源檔案也就是.java檔案編譯成.class檔案
2、 執行：先啟動java虛拟機，不同的作業系統有不同的jvm，是以java跨平台
再通過JVM加載HelloWorld.class位元組碼檔案。并加載main方法執行程式
1.6.2 下載下傳最新版本eclipse
自己下載下傳并使用
1.6.3 JDK JRE JVM的關系
1、JDK--Java Development Kit是針對Java開發員的産品，是整個Java的核心，包括了Java運作環境JRE、Java工具和Java基礎類庫
2、JRE--Java Runtime Environment是運作JAVA的運作時環境，包含JVM和Java核心類庫
3、JVM--Java Virtual Machine，Java虛拟機的縮寫，是整個java實作跨平台的最核心的部分，能夠運作以Java語言寫作的軟體程式
1.6.4 Java的”一次編寫，處處運作”是如何實作的？
Java程式會被編譯成位元組碼組成的class檔案，這些位元組碼可以運作在任何平台，是以Java是平台獨立的
2.資料類型+運算符
2.1 前言
2.1.1 辨別符
可以簡單的了解為一個名字。在Java中，我們需要辨別代碼的很多元素，包括類名、方法、字段、變量、包名等。我們選擇的名稱就稱為辨別符，并且遵循以下規則：
A. 辨別符可以由字母、數字、下劃線（_）、美元符（$）組成，但不能包含 @、%、空格等其它特殊字元
B. 不能以數字開頭
C. 辨別符是嚴格區分大小寫的
D. 辨別符的命名最好能反映出其作用，做到見名知意
2.1.2 關鍵字
在java語言中已經被賦予特定意義的一些單詞。一共有53個關鍵字。其中有兩個保留字:const和goto。關鍵字不能被用作辨別符！！
2.1.3 注釋
Java代碼的解釋說明。不影響程式的運作，用于輔助讀程
//單行注釋
2.1.4 變量
在JAVA中，有的資料值是不固定的，總在變，我們還需要記錄這些值，我們可以把這些值了解為變量
我們通過三個元素來描述變量：變量類型，變量名以及變量值
int age=18; //聲明int類型的變量并指派
String tel; //聲明String類型的變量
注意：
1、 變量名必須是一個有效的辨別符
2、 變量名不可以使用java關鍵字
3、 變量名不能重複
2.1.5 常量
在程式運作過程中一緻不會改變的量成為常量
定義常量：
Java 語言使用 final 關鍵字來定義一個常量，其文法如下所示：
final dataType variableName = value
其中，final 是定義常量的關鍵字，dataType 指明常量的資料類型，variableName 是變量的名稱，value 是初始值
final 關鍵字表示最終的，它可以修改很多元素，修飾變量就變成了常量。例如，以下語句使用 final 關鍵字聲明常量
public class HelloWorld {
// 靜态常量
public static final double PI = 3.14;
// 聲明成員常量
final int y = 10;
public static void main(String[] args) {
// 聲明局部常量
final double x = 3.3;
}
}
常量有三種類型：靜态常量、成員常量和局部常量
2.2 資料類型
2.2.1 基本類型(八種)
2.2.1.1 介紹
位bit 位元組byte 1byte=8bit
| 類型名稱 | 位元組空間 | 取值範圍 | |
| 整數型 | byte | 1 | -27到27-1 或者 -128到127 |
| short | 2 | -215到215-1 | |
| int | 4 | -231到231-1 | |
| long | 8 | -263到263-1 | |
| 浮點型 | float | 4 | 單精度，對小數部分的精度要求不高 |
| double | 8 | 雙精度，精确的小數部分并操作值很大時 | |
| 字元 | char | 2 | 0到65535 |
| 布爾 | boolean | 1 | 真true 假false |
2.2.1.2 練習1：最大值最小值
package day0102;
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);
//=====整型測試結束
//=====浮點測試開始
float i=Float.MIN_VALUE;
float j=Float.MAX_VALUE;
double k=Double.MIN_VALUE;
double l=Double.MAX_VALUE;
System.out.println(i);
System.out.println(j);
System.out.println(k);
System.out.println(l);
//=====浮點測試結束
//=====字元測試開始
char a='a';
char b=97;
char c='b';
char d=98;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
//=====字元測試結束
}
}
2.2.1.3 練習2：輸入個人資訊
王海濤今年20歲，月薪20000，奉勸大家拼命學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();
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);
}
}
2.2.1.4 練習3：圓形面積
圓的面積：π*r*r
圓的周長：2*π*r
package day0104;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.println("請輸入圓的半徑");
double r=new Scanner(System.in).nextDouble();
System.out.println(3.14*r*r);
}
}
2.2.1.5 練習4：變量交換
接收使用者輸入的值：假設a=1,b=2将a和b的值做交換
package day0103;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.print("輸入整數a:");
int a=new Scanner(System.in).nextInt();
System.out.print("輸入整數b:");
int b=new Scanner(System.in).nextInt();
int t=a;
a=b;
b=t;
System.out.println(a);
System.out.println(b);
}
}
2.2.1 引用類型
引用類型是一個對象類型，值是什麼呢？它的值是指向記憶體空間的引用，就是位址，所指向的記憶體中儲存着變量所表示的一個值或一組值。如：類，接口，數組
2.3 基本類型的字面值（5條）
2.3.1 整數字面值是int類型
int a = 999999999;//錯，右側是int類型，但是超出範圍
2.3.2 byte，short，char三種比int小的整數可以用範圍内的值直接指派
byte b=127;//對
byte b=128;//錯，右面已經超過byte範圍是int類型的資料
2.3.3 浮點數的字面值是double類型
double a=3.14;//對
float a=3.14;//錯，右面是double，float是四位元組double是八位元組存不下
2.3.4 字面值字尾l f d
L –long 如：long a = 99999999999;//錯，超出範圍，解決方案加L
F –float 如：float a = 3.14;//錯，右面是double類型，解決方案加F
D –double 如：double a=3;//錯，右面是int，解決方案加D或者改成3.0
2.3.5 進制字首
0x - 16進制
0 -8進制
\u -char類型，16進制
2.4 基本類型的類型轉換
2.4.1 小到大（隐式轉換）
Byte a =120;
Int b=a;//直接轉
2.4.2 大到小（顯式轉換）
需要強制類型轉換
int xx = 356;
byte y=(byte) xx;
注意：小數轉成整數，小數直接舍棄
2.5 運算規則（5條）
2.5.1 計算結果的資料類型，與最大類型一緻
3/2 得1 ，而不是1.5，結果是int類型
3d/2 得1.5，相當于double/int，結果是double類型
2.5.2 byte,short,char三種比int小的整數不能互轉，運算時會先自動轉換成int
byte a=3;
byte b=4;
byte c=a+b;//錯，運作時，byte會先自動轉成int再運算，int+int還是int
2.5.3 整數運算溢出
整數運算，類似于一個中标，轉到最大時，再轉會回到最小
計算：光速運作一年的長度是多少米
System.out.println(300000000*60*60*24*365);
System.out.println(300000000l*60*60*24*365);
2.5.4 浮點數運算不精确
java提供了解決方案，後面就會講到
System.out.println(1-0.8);
System.out.println(4.35*100);
2.5.5 浮點數的特殊值
Infinity 無窮大 3.14/0
Nan not a number 0/0.0
2.6 拓展
2.6.1 什麼是顯示類型轉換和隐式類型轉換
在定義變量時，有許多要注意的問題，一不小心就會出現損失精度或者不相容類型等問題
例如：
1.定義長整型資料時，必須加字尾l或L
long l =123456789012345L
2.定義單精度類型時（7-8位有效數字），必須加字尾 f 或 F
float f = 12.5F
3. boolean類型不可以轉換為其它的資料類型
這其中，我們常常會遇到資料類型的轉換問題，最為常見的要屬隐式轉換和強制轉換了，我們來分析一下
隐式轉換
特征：從小到大，可以隐式轉換，資料類型将自動提升
byte，short，char -->int -->long -->float -->double
注意：long是8個位元組，float是4個位元組
long是整數，float是浮點型，整數和浮點數的存儲規則不一樣，記住一點long的範圍是小于float的
例 :
byte a=10;
int b=a;
當編譯int b=a 時，a隐式轉換為int類型
強制轉換
特征:
從大到小（如果你明确知道資料是可以用該資料類型來表示的，可以用強制轉換）
格式：
（轉換後的資料類型）變量或者值
注：一般情況下，根本不推薦使用強制類型轉換
例 :
int a=10;
byte b=(byte)a;
當編譯 byte b=(byte)a時， a被強制轉換為byte類型
2.6.2 char 型變量中能不能存儲一個中文漢字，為什麼？
char 類型可以存儲一個中文漢字，因為 Java 中使用的編碼是 Unicode（不選擇任何特定的編碼，直接使用字元在字元集中的編号，這是統一的唯一方法），一個 char 類型占 2 個位元組（16 比特），是以放一個中文是沒問題的
3.方法+流程控制+循環
3.1 運算符
3.1.1 概述
| 算術運算符 | + - * / | 基本運算 |
| % | 取餘數，求模，算整除 | |
| ++ -- | 自增 自減 | |
| 比較運算符 | == | 相等比較 |
| ！= | 不等比較 | |
| 邏輯運算符 | && & | 邏輯與(短路與)，兩邊同為真結果才為真 |
| || | | 邏輯或(短路或)，兩邊隻要有一個真結果就是真 | |
| + | 字元串連接配接 | |
| ！ | 非，非真是假，非假是真 | |
| 三元運算符 | ？： | 三項運算 1?2:3 1是真取2，1是假取3 |
| 指派運算符 | = | 指派運算 |
| += -= *= /= | 複合的指派運算 a+=2;//a=a+2 |
3.1.2 練習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();
String r="平年";
if(y%4==0){
if(y%100!=0){
r="閏年";
}
}
if(y%400==0){
r="閏年";
}
//或者
//if((y%4==0&&y%100!=0)||y%400==0){
// r="閏年";
//}
System.out.println(y+"年是"+r);
}
}
3.1.3 練習2：自增自減
int a = 1;
System.out.println(a++);//先取值再自增
int b=1;
System.out.println(++b);//先自增再取值
int c=1;
int d = c++;
System.out.println(d);
System.out.println(c);
int e = ++c;
System.out.println(e);
System.out.println(c);
3.1.4 練習3：求兩個數裡的大值
3.1.5 練習4：求三個數的最大值
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);
}
}
3.2 分支結構1：if
3.2.1 概述
順序結構的程式雖然能解決計算、輸出等問題，但不能做判斷再選擇。對于要先做判斷再選擇的問題就要使用分支結構
3.2.2 形式
單分支：
if(判斷條件){
代碼...
}
多分支：
if(判斷條件){
代碼1...
}else{
代碼2...
}
嵌套分支：
if(判斷條件1){
代碼1...
}else if(條件2){
代碼2...
} else if(判斷條件3){
代碼3...
}else{
代碼4...
}
3.2.3 練習1：商品打折
接收使用者輸入的原價。滿1000打9折。滿2000打8折。滿5000打5折
package day999;
import java.util.Scanner;
public class ttt {
public static void main(String[] args) {
System.out.println("輸入總原價");
double price = new Scanner(System.in).nextDouble();
double now = f(price);
System.out.println(now);
}
public static double f(double p){ //靜态方法直接調用
if(p>5000){
p=p*0.5;
}else if(p>2000){
p=p*0.8;
}else if(p>1000){
p=p*0.9;
}
return p;
}
}
3.2.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以内的值");
}
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("不及格");
}
}
}
3.3 分支結構2：switch
3.3.1 概述
當一個case成立，從這個case向後穿透所有case，包括default，直到程式結束或者遇到break程式才結束
3.3.2 形式
switch(expr1)中,expr1是一個整數表達式， 整數表達式可以是int基本類型或Integer包裝類型,由于byte,short,char都可以隐含轉換為int，是以也支援
注意： jdk1.7以後新增 String
switch(變量或者表達式){ //int、integer、byte、short、char、String
case 1:
case 2:
case 3:
case 4:
default:
}
3.3.3 練習1：數字比對
package day003;
import java.util.Scanner;
public class Test1_數字比對 {
public static void main(String[] args) {
int i=3;
switch (i) {
case 1:
System.out.println("1");
break;
case 2:
System.out.println("2");
break;
case 3:
System.out.println("3");
// break;
default:
System.out.println("default");
break;
}
}
}
3.4 循環結構1：for
3.4.1 概述
循環結構是指在程式中需要反複執行某個功能而設定的一種程式結構
它由循環體中的條件，判斷繼續執行某個功能還是退出循環
根據判斷條件,循環結構又可細分為先判斷後執行的循環結構和先執行後判斷的循環結構
3.4.2 形式
for(開始條件；循環條件；更改條件){
循環體代碼…
}
3.4.3 練習1：列印0到10
package day999;
public class ttttt {
public static void main(String[] args) {
f1();
}
public static void f1(){
for (int i = 0; i <= 10; i++) {
System.out.print(i);
}
}
}
3.4.4 練習2：列印10到0
package day999;
public class ttttt {
public static void main(String[] args) {
f2();
}
public static void f2(){
for(int i=10;i>=0;i--){
System.out.print(i);
}
}
}
3.4.5 練習3：列印8,88,888,8888
package day999;
public class ttttt {
public static void main(String[] args) {
f();
}
public static void f(){
for(int i=8;i<=10000;i=i*10+8){
System.out.println(i);
}
}
}
3.5 拓展
3.5.1 &和&&的差別
當一個&表達式在求值的時候，兩個操作數都會被求值，&&更像 是一個操作符的快捷方式
當一個&&表達式求值的時候，先計算第一個操作數，如果它傳回true才會計算第二個操作數
如果第一個操作數 取值為fale,第二個操作數就不會被求值
3.5.2 a=a+4和a+=4的差別
對于a = a + 1和a += 1，效果上，差不多，都可以對a進行加一操作，但是也有差別
byte a = 1;
a = a + 1; //報錯，編譯無法通過
a += 1; //正常，編譯可以通過，并且程式正常運作
因為java中有個機制byte、short或char在做算數運算的時候，會先自動上升為int類型，然後再做運算，是以第二行得到的結果是一個int的資料，但是卻要将它指派個一個byte類型的變量，是以會報錯
而 += 運算符，有一個重要的特性：不會改變變量的類型，是以
byte a = 1;
a += 1; //等效于下面
a = (byte)(a + 1)
a += 1在執行的時候，會在底層自動的進行強制類型轉換，當然，轉換為什麼類型，要視a原本的類型而定
結論：a = a + 1可能會改變a的資料類型，但a += 1 一定不會改變a原本的資料類型
3.5.3 求【0,100】中，奇數的個數
int count = 0;
for(int i = 0; i <= 100; i++){
if(i % 2 == 1){
count++;
}
}
System.out.println(count);
3.5.4 求【0,100】中，偶數的和
int sum = 0;
for(int i = 0; i <= 100; i++){
if(i % 2 == 0){
sum += i;
}
}
System.out.println(sum);
4.循環+數組
4.1 嵌套for循環
4.1.1 概述
根據外層的條件，判斷裡層能否執行，如果能執行，就把裡層代碼都循環完畢後，再繼續執行外層，繼續判斷
4.1.2 形式
for(…){
for(…){
...
}
}
4.1.3 入門案例
package day0000;
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();
}
}
}
4.1.4 練習1：列印正方形
//正方形
for(int i=1;i<5;i++){
for(int j=1;j<5;j++){
System.out.print("*");
}
System.out.println();
}
4.1.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();
}
}
4.1.6 練習3：列印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
//99乘法表
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();
}
}
4.2 break和continue
用來終止循環，可以用兩種方式
4.2.1 形式
break: 中斷目前循環，簡單粗暴
for(){
代碼1...
if(條件){
代碼3…
break; //如果成立，直接跳出這個for循環
}
代碼2…
}
continue：跳出本次循環，進入下一輪
for(){
代碼1
if(條件){
代碼3…
continue;//如果成立，跳出本次for循環，進入下一輪
}
代碼2…
}
4.2.2 練習1：找數字88
接收使用者輸入的100次數字，如果不是88繼續輸入，找到88就傳回
package day003;
import java.util.Scanner;
public class Test4_breakcontinue {
public static void main(String[] args) {
f2();
}
//找88
private static void f2() {
for(int i=1;i<=100;i++){
//一直輸入…
int j = new Scanner(System.in).nextInt();
if(j!=88){
continue;//繼續輸入
}
if(j==88){
System.out.println("找到了88...");
break;
}
}
}
}
4.3 循環結構2：while
先判斷，再執行
4.3.1 格式
while(執行條件){
代碼…
}
4.3.2 練習1：猜數字
産生一個随機數，和使用者一直在輸入的數字比較
package day004;
import java.util.Random;
import java.util.Scanner;
public class Test5_猜數字 {
public static void main(String[] args) {
//系統産生随機數，從0開始，要從1開始就加1
int i = new Random().nextInt(1000)+1;
//System.out.println(i);
System.out.println("猜1~1000的随機數");
while(true){
//接收使用者輸入的值
int sc = new Scanner(System.in).nextInt();
//判斷
if(sc>i){
System.out.println("大");
}else if(sc<i){
System.out.println("小");
}else{
System.out.println("中了中了");
break;
}
}
}
}
4.4 循環結構3：do-while
先執行，再判斷
4.4.1 格式
do{
循環體…
}while(執行條件);
注意：do…while和while，前者是先執行循環體，後者是先判斷再執行循環體
4.4.1 練習1：猜數字
産生一個随機數，和使用者一直在輸入的數字比較
package day004;
import java.util.Random;
import java.util.Scanner;
public class Test5_猜數字 {
public static void main(String[] args) {
//系統産生随機數，從0開始，要從1開始就加1
int i = new Random().nextInt(1000)+1;
//System.out.println(i);
System.out.println("猜1~1000的随機數");
do{
//接收使用者輸入的值
int sc = new Scanner(System.in).nextInt();
//判斷
if(sc>i){
System.out.println("大");
}else if(sc<i){
System.out.println("小");
}else{
System.out.println("right");
break;
}
}while(true);
}
}
4.5 變量
4.5.1 概念
可以改變的數，稱為變量
一般通過三部分來描述一個變量：變量類型，變量名，變量值
其中三部分都是可以改變的，根據需要來确定即可
變量的使用原則：就近原則，盡量控制到最小範圍
4.5.2 局部變量
定義在方法裡，或者局部代碼塊中。
注意：必須手動初始化，來配置設定記憶體。如：int i=5;
作用域也就是方法裡或者局部代碼塊裡，方法運作完記憶體就釋放了
4.5.3 成員變量
定義在類裡
注意：不用初始化，也會自動被初始化成預設值
作用域是整個類中，類消失了，變量才釋放
| 基本類型 | 預設值 |
| byte | |
| short | |
| char | '\u0000' |
| int | |
| long | 0L |
| float | 0.0f |
| double | 0.0d |
| boolean | false |
4.5.4 測試
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;
//3、變量的就近原則，附近有同名的會去執行最近的
System.out.println(sum); //10
}
}
4.6 拓展：
4.6.1 三種循環的差別
三種循環都可以互相代替
1、 for：知道循環次數
2、 while/do while：當循環次數不确定時
3、 while：先判斷，不符合規則，不執行代碼
4、 do while：代碼最少被執行一次，再去判斷，符合規則，再次執行代碼
4.6.2 列印右直角三角形
*
**
***
****
*****
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--){
System.out.print(" ");
}
//*号三角
for(int j=1;j<=i;j++){
System.out.print("*");
}
System.out.println();
}
}
}
4.6.3 列印全三角形
*
***
*****
*******
*********
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--){
System.out.print(" ");
}
//列印*号的正三角
for(int k=1;k<=i*2-1;k++){
System.out.print("*");
}
System.out.println();
}
}
}
5 Day05--數組+變量
5.1 方法
5.1.1 概述
被命名的代碼塊，方法可以含參數可以不含參數
可以提高代碼的複用性
5.1.2 形式
修飾符 傳回值 方法名( 參數 ){
方法體;
}
5.1.3 練習1：方法調用
public class Test1_方法 {
public static void main(String[] args) {
System.out.println(1);
f();
System.out.println(2);
}
private static void f() {
System.out.println(3); //132
}
}
5.1.4 練習2：方法參數
package day0203_平年閏年;
public class Test1_參數 {
public static void main(String[] args) {
System.out.println(1);
f(2);
System.out.println(2);
}
static void f(int x){
System.out.println(x*x); //142
}
}
5.1.5 練習3：方法傳回值
package day999;
public class tt {
public static void main(String[] args) {
System.out.println(1);
int num=f3(5);
System.out.println(num);
String str = f4("學習使我快樂");
System.out.println(str);
System.out.println(2);
}
public static String f4(String desc){
return desc+",我信你個鬼";
}
public static int f3(int i){
return i*10;
}
}
5.2 方法的重載
5.2.1 概念
方法重載是指在一個類中定義多個同名的方法，但要求每個方法具有不同的參數清單(也就是說參數的個數和類型不同)
程式調用方法時，可以通過傳遞給它們的不同個數和類型的參數來決定具體使用哪個方法
5.2.2 練習1：數字求和
package day005;
public class Test5_方法重載 {
public static void main(String[] args) {
int a=10;
int b=20;
String name="lisi";
f1();
f1(a);
f1(a,b);
f1(a,b,name);
}
private static void f1(int a, int b, String name) {
System.out.println(a+b+name); //30name
}
private static void f1() {
System.out.println("f1()");
}
private static void f1(int a) {
System.out.println(a);
}
private static void f1(int a, int b) {
System.out.println(a+b);
}
}
5.2.3 練習2：資料的列印
5.3 數組
5.3.1 概念
數組Array是用于儲存多個相同類型資料的集合
想要擷取數組中的元素值，可以通過元素的下标來擷取，下标是從0開始的
5.3.2 建立數組
一般分為動态初始化和靜态初始化
動态初始化：int[] a = new int[5];
Ø 建立int[],長度是5
Ø 剛建立好的數組都是預設值0，int類型的資料預設值是0
Ø 把數組的位址值給變量a儲存
靜态初始化1：int[] a ={1,2,3,4,5,6,7,8};
靜态初始化2：int[] a =new int[]{1,2,3,4,5};
5.3.3 練習1：數組中存入hello
package day004;
import java.util.Arrays;
public class Test6_數組 {
public static void main(String[] args) {
System.out.println("test...");
f1();
}
private static void f1() {
int[] i = new int[]{1,2,3,4,5};
System.out.println(Arrays.toString(i));
char[] a = new char[5];
a[0]='h';
a[1]='e';
a[2]='l';
a[3]='l';
a[4]='o';
System.out.println(Arrays.toString(a));
}
}
5.3.4 數組的長度
Ø length屬性擷取數組長度
Ø 數組一旦建立，長度不可變
Ø 允許0長度的數組
5.4 數組的周遊
從頭到尾，依次通路數組的位置
5.4.1 形式
for(int i=0;i<a.length;i++){
syso(a[i]);
}
5.4.2 練習1：輸出每個月的天數
package day004;
public class Test9_GetDay{
public static void main(String[] args){
int[] days=new int[]{31,29,31,30,31,30,31,31,30,31,30,31};
for(int i=0;i<days.length;i++){
System.out.println((i+1)+"月有"+days[i]+"天");
}
}
}
5.4.3 練習2：周遊數組，存入1到10
package day004;
public class Test7_數組周遊 {
public static void main(String[] args) {
f1();
}
private static void f1() {
int[] arr=new int[10];
for (int i = 0; i < arr.length; i++) {
arr[i]=i+1;
}
System.out.println(Arrays.toString(arr));
}
}
5.4.4 練習3：建立随機數組
擷取100以内的随機值的數組
package com.tedu.hello;
import java.util.Arrays;
import java.util.Random;
public class t {
public static void main(String[] args) {
f();
}
private static void f() {
int[] a = new int[5];
for (int i = 0; i < a.length; i++) {
a[i]=new Random().nextInt(100)+1;
}
System.out.println(Arrays.toString(a));
}
}
5.5 數組工具類Arrays
5.5.1 Arrays.toString(數組)
把數組裡的資料，用逗号連接配接成一個字元串
格式：[10, 14, 20, 46, 51]
5.5.2 Arrays.sort(數組)
對數組排序，對于基本類型的數組使用優化後的快速排序算法，效率高
對引用類型數組，使用優化後的合并排序算法
5.5.3 Arrays.copyOf(數組，新的長度)
把數組複制成一個指定長度的新數組
新數組長度大于原數組，相當于複制，并增加位置。--數組的擴容
新數組長度小于原數組，相當于截取前一部分資料。--數組的縮容
5.5.4 測試
int[] a = Arrays.copyOf(arr, 10); //數組的複制，大于原來長度相當于擴容
System.out.println(Arrays.toString(a)); //[12, 30, 20, 90, 34, 0, 0, 0, 0, 0]
System.out.println(a.length); //10
int[] a2 = Arrays.copyOf(arr, 3); //數組的複制，小于原來長度相當于截取前幾個資料
System.out.println(Arrays.toString(a2)); //[12, 30, 20]
System.out.println(a2.length); //3
5.6 拓展：
5.6.1 了解二維數組
存放數組的數組，也就是說數組裡存的還是數組的資料形式
5.6.2 了解冒泡排序
相鄰位置比較，從小到大排序，如果小就往前換。i代表從頭到尾周遊循環資料
package day0000;
import java.util.Arrays;
import java.util.Random;
public class TT {
public static void main(String[] args) {
int[] arr = new int[]{43, 36, 45, 18, 24,9,20,32};
int[] arrnew = f1(arr);
System.out.println(Arrays.toString(arrnew));
}
private static int[] f1(int[] a) {
//外循環控制循環次數，如果5個數字，循環4次就行
for (int i = 0; i < a.length-1; i++) {
//内循環控制比大小，循環次數和外循環一樣
for (int j = 0; j < a.length-i-1; j++) {
if(a[j]>a[j+1]){
int t = a[j];
a[j]=a[j+1];
a[j+1]=t;
}
}
}
return a;
}
5.6.3 了解其他算法
如：合并算法，二分算法，快速算法等，冒泡最常見，也是面試中出現率最高的
//二分查找法(折半查找法)，實作查找指定數值在元素有序的數組中存儲的位置（索引），傳回該位置（索引）。
public static int halfSearch(int[] arr,int number){
int min =0; //最小下标
int max =arr.length-1; //最大下标
int mid = 0; //中間下标
while (min<max){
//沒找到,更新範圍繼續找
mid = (min+max)/2;
if (arr[mid]>number){ //number在mid的左邊
max = mid-1; //改變最大下标
}else if(arr[mid]<number){ //number在mid的右邊
min = mid+1; //改變最小下标
}else{
return mid;
}
}
return -1;
}